[range] refactor use of examples in documentation to avoid redundancy

[SVN r82344]

test/Jamfile.v2

@@ -31,21 +31,7 @@ rule range-test ( name : includes * )
 }
 
 test-suite range :
-    [ compile ../doc/reference/adaptors/examples/adjacent_filtered.cpp : : example_adjacent_filtered ]
-    [ compile ../doc/reference/adaptors/examples/copied.cpp : : example_copied ]
-    [ compile ../doc/reference/adaptors/examples/filtered.cpp : : example_filtered ]
-    [ compile ../doc/reference/adaptors/examples/indexed.cpp : : example_indexed ]
-    [ compile ../doc/reference/adaptors/examples/indirected.cpp : : example_indirected ]
-    [ compile ../doc/reference/adaptors/examples/map_keys.cpp : : example_map_keys ]
-    [ compile ../doc/reference/adaptors/examples/map_values.cpp : : example_map_values ]
-    [ compile ../doc/reference/adaptors/examples/replaced.cpp : : example_replaced ]
-    [ compile ../doc/reference/adaptors/examples/replaced_if.cpp : : example_replaced_if ]
-    [ compile ../doc/reference/adaptors/examples/reversed.cpp : : example_reversed ]
-    [ compile ../doc/reference/adaptors/examples/sliced.cpp : : example_sliced ]
-    [ compile ../doc/reference/adaptors/examples/strided.cpp : : example_strided ]
     [ compile ../doc/reference/adaptors/examples/tokenized.cpp : : example_tokenized ]
-    [ compile ../doc/reference/adaptors/examples/transformed.cpp : : example_transformed ]
-    [ compile ../doc/reference/adaptors/examples/uniqued.cpp : : example_uniqued ]
 	[ compile-fail compile_fail/iterator_range1.cpp ]
 	[ range-test adaptor_test/adjacent_filtered ]
 	[ range-test adaptor_test/copied ]

test/adaptor_test/adjacent_filtered_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[adjacent_filtered_example
 #include <boost/range/adaptor/adjacent_filtered.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -16,6 +17,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 #include <boost/test/test_tools.hpp>
@@ -23,27 +25,32 @@
 
 namespace
 {
-    void adjacent_filtered_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+void adjacent_filtered_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::vector<int> input;
-        input += 1,1,2,2,2,3,4,5,6;
+    std::vector<int> input;
+    input += 1,1,2,2,2,3,4,5,6;
 
-        boost::copy(
-            input | adjacent_filtered(std::not_equal_to<int>()),
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | adjacent_filtered(std::not_equal_to<int>()),
+        std::ostream_iterator<int>(std::cout, ","));
+    
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 1,2,3,4,5,6;
 
-        std::vector<int> reference;
-        reference += 1,2,3,4,5,6;
+    std::vector<int> test;
+    boost::push_back(test, input | adjacent_filtered(std::not_equal_to<int>()));
 
-        std::vector<int> test;
-        boost::push_back(test, input | adjacent_filtered(std::not_equal_to<int>()));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/copied_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[copied_example
 #include <boost/range/adaptor/copied.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 #include <boost/test/test_tools.hpp>
@@ -22,28 +24,32 @@
 
 namespace
 {
-    void copied_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+void copied_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9,10;
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9,10;
 
-        boost::copy(
-            input | copied(1, 5),
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | copied(1, 5),
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 2,3,4,5;
 
-        std::vector<int> reference;
-        reference += 2,3,4,5;
+    std::vector<int> test;
+    boost::push_back(test, input | copied(1, 5));
 
-        std::vector<int> test;
-        boost::push_back(test, input | copied(1, 5));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/filtered_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[filtered_example
 #include <boost/range/adaptor/filtered.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,32 +24,39 @@
 
 namespace 
 {
-    struct is_even
-    {
-        bool operator()( int x ) const { return x % 2 == 0; }
-    };
+//->    
+struct is_even
+{
+    bool operator()( int x ) const { return x % 2 == 0; }
+};
 
-    void filtered_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+//<-
+void filtered_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9;
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9;
 
-        boost::copy(
-            input | filtered(is_even()),
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | filtered(is_even()),
+        std::ostream_iterator<int>(std::cout, ","));
 
-        std::vector<int> reference;
-        reference += 2,4,6,8;
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 2,4,6,8;
 
-        std::vector<int> test;
-        boost::push_back(test, input | filtered(is_even()));
+    std::vector<int> test;
+    boost::push_back(test, input | filtered(is_even()));
 
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/indexed_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[indexed_example
 #include <boost/range/adaptor/indexed.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,65 +24,72 @@
 
 namespace 
 {
-    template<class Iterator>
-    void display_element_and_index(Iterator first, Iterator last)
+
+template<class Iterator1, class Iterator2>
+void check_element_and_index(
+        Iterator1 test_first,
+        Iterator1 test_last,
+        Iterator2 reference_first,
+        Iterator2 reference_last)
+{
+    BOOST_CHECK_EQUAL( std::distance(test_first, test_last),
+                       std::distance(reference_first, reference_last) );
+
+    int reference_index = 0;
+
+    Iterator1 test_it = test_first;
+    Iterator2 reference_it = reference_first;
+    for (; test_it != test_last; ++test_it, ++reference_it, ++reference_index)
     {
-        for (Iterator it = first; it != last; ++it)
-        {
-            std::cout << "Element = " << *it << " Index = " << it.index() << std::endl;
-        }
+        BOOST_CHECK_EQUAL( *test_it, *reference_it );
+        BOOST_CHECK_EQUAL( test_it.index(), reference_index );
     }
+}
 
-    template<class SinglePassRange>
-    void display_element_and_index(const SinglePassRange& rng)
+template<class SinglePassRange1, class SinglePassRange2>
+void check_element_and_index(
+    const SinglePassRange1& test_rng,
+    const SinglePassRange2& reference_rng)
+{
+    check_element_and_index(boost::begin(test_rng), boost::end(test_rng),
+        boost::begin(reference_rng), boost::end(reference_rng));
+}
+//->    
+template<class Iterator>
+void display_element_and_index(Iterator first, Iterator last)
+{
+    for (Iterator it = first; it != last; ++it)
     {
-        display_element_and_index(boost::begin(rng), boost::end(rng));
+        std::cout << "Element = " << *it << " Index = " << it.index() << std::endl;
     }
+}
 
-    template<class Iterator1, class Iterator2>
-    void check_element_and_index(
-            Iterator1 test_first,
-            Iterator1 test_last,
-            Iterator2 reference_first,
-            Iterator2 reference_last)
-    {
-        BOOST_CHECK_EQUAL( std::distance(test_first, test_last),
-                           std::distance(reference_first, reference_last) );
+template<class SinglePassRange>
+void display_element_and_index(const SinglePassRange& rng)
+{
+    display_element_and_index(boost::begin(rng), boost::end(rng));
+}
 
-        int reference_index = 0;
+//<-
+void indexed_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        Iterator1 test_it = test_first;
-        Iterator2 reference_it = reference_first;
-        for (; test_it != test_last; ++test_it, ++reference_it, ++reference_index)
-        {
-            BOOST_CHECK_EQUAL( *test_it, *reference_it );
-            BOOST_CHECK_EQUAL( test_it.index(), reference_index );
-        }
-    }
+    std::vector<int> input;
+    input += 10,20,30,40,50,60,70,80,90;
 
-    template<class SinglePassRange1, class SinglePassRange2>
-    void check_element_and_index(
-        const SinglePassRange1& test_rng,
-        const SinglePassRange2& reference_rng)
-    {
-        check_element_and_index(boost::begin(test_rng), boost::end(test_rng),
-            boost::begin(reference_rng), boost::end(reference_rng));
-    }
+    display_element_and_index( input | indexed(0) );
 
-    void indexed_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
-
-        std::vector<int> input;
-        input += 10,20,30,40,50,60,70,80,90;
-
-        display_element_and_index( input | indexed(0) );
-
-        check_element_and_index(
-            input | indexed(0),
-            input);
-    }
+//=    return 0;
+//=}
+//]
+    check_element_and_index(
+        input | indexed(0),
+        input);
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/indirected_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[indirected_example
 #include <boost/range/adaptor/indirected.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/shared_ptr.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,30 +24,34 @@
 
 namespace 
 {
-    void indirected_example_test()
-    {
-        using namespace boost::adaptors;
+void indirected_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
 
-        std::vector<boost::shared_ptr<int> > input;
+    std::vector<boost::shared_ptr<int> > input;
 
-        for (int i = 0; i < 10; ++i)
-            input.push_back(boost::shared_ptr<int>(new int(i)));
-        
-        boost::copy(
-            input | indirected,
-            std::ostream_iterator<int>(std::cout, ","));
+    for (int i = 0; i < 10; ++i)
+        input.push_back(boost::shared_ptr<int>(new int(i)));
+    
+    boost::copy(
+        input | indirected,
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    for (int i = 0; i < 10; ++i)
+        reference.push_back(i);
 
-        std::vector<int> reference;
-        for (int i = 0; i < 10; ++i)
-            reference.push_back(i);
+    std::vector<int> test;
+    boost::push_back(test, input | indirected);
 
-        std::vector<int> test;
-        boost::push_back(test, input | indirected);
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/map_keys_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[map_keys_example
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -16,6 +17,7 @@
 #include <map>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -23,29 +25,33 @@
 
 namespace 
 {
-    void map_keys_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+void map_keys_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::map<int,int> input;
-        for (int i = 0; i < 10; ++i)
-            input.insert(std::make_pair(i, i * 10));
+    std::map<int,int> input;
+    for (int i = 0; i < 10; ++i)
+        input.insert(std::make_pair(i, i * 10));
 
-        boost::copy(
-            input | map_keys,
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | map_keys,
+        std::ostream_iterator<int>(std::cout, ","));
 
-        
-        std::vector<int> reference;
-        reference += 0,1,2,3,4,5,6,7,8,9;
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 0,1,2,3,4,5,6,7,8,9;
 
-        std::vector<int> test;
-        boost::push_back(test, input | map_keys);
+    std::vector<int> test;
+    boost::push_back(test, input | map_keys);
 
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/map_values_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[map_values_example
 #include <boost/range/adaptor/map.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -16,6 +17,7 @@
 #include <map>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -23,29 +25,33 @@
 
 namespace 
 {
-    void map_values_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+void map_values_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::map<int,int> input;
-        for (int i = 0; i < 10; ++i)
-            input.insert(std::make_pair(i, i * 10));
+    std::map<int,int> input;
+    for (int i = 0; i < 10; ++i)
+        input.insert(std::make_pair(i, i * 10));
 
-        boost::copy(
-            input | map_values,
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | map_values,
+        std::ostream_iterator<int>(std::cout, ","));
 
-        
-        std::vector<int> reference;
-        reference += 0,10,20,30,40,50,60,70,80,90;
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 0,10,20,30,40,50,60,70,80,90;
 
-        std::vector<int> test;
-        boost::push_back(test, input | map_values);
+    std::vector<int> test;
+    boost::push_back(test, input | map_values);
 
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/replaced_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[replaced_example
 #include <boost/range/adaptor/replaced.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,28 +24,32 @@
 
 namespace 
 {
-    void replaced_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+void replaced_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,2,5,2,7,2,9;
-        
-        boost::copy(
-            input | replaced(2, 10),
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,2,5,2,7,2,9;
+    
+    boost::copy(
+        input | replaced(2, 10),
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 1,10,3,10,5,10,7,10,9;
 
-        std::vector<int> reference;
-        reference += 1,10,3,10,5,10,7,10,9;
+    std::vector<int> test;
+    boost::push_back(test, input | replaced(2, 10));
 
-        std::vector<int> test;
-        boost::push_back(test, input | replaced(2, 10));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/replaced_if_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[replaced_if_example
 #include <boost/range/adaptor/replaced_if.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,32 +24,39 @@
 
 namespace 
 {
-    struct is_even
-    {
-        bool operator()(int x) const { return x % 2 == 0; }
-    };
+//->
+struct is_even
+{
+    bool operator()(int x) const { return x % 2 == 0; }
+};
 
-    void replaced_if_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+//<-
+void replaced_if_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9;
-        
-        boost::copy(
-            input | replaced_if(is_even(), 10),
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9;
+    
+    boost::copy(
+        input | replaced_if(is_even(), 10),
+        std::ostream_iterator<int>(std::cout, ","));
 
-        std::vector<int> reference;
-        reference += 1,10,3,10,5,10,7,10,9;
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 1,10,3,10,5,10,7,10,9;
 
-        std::vector<int> test;
-        boost::push_back(test, input | replaced_if(is_even(), 10));
+    std::vector<int> test;
+    boost::push_back(test, input | replaced_if(is_even(), 10));
 
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/reversed_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[reversed_example
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,25 +24,29 @@
 
 namespace 
 {
-    void reversed_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+void reversed_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9;
-        
-        boost::copy(
-            input | reversed,
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9;
+    
+    boost::copy(
+        input | reversed,
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> test;
+    boost::push_back(test, input | reversed);
 
-        std::vector<int> test;
-        boost::push_back(test, input | reversed);
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( input.rbegin(), input.rend(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( input.rbegin(), input.rend(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/sliced_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[sliced_example
 #include <boost/range/adaptor/sliced.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,28 +24,32 @@
 
 namespace 
 {
-    void sliced_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+void sliced_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9;
-        
-        boost::copy(
-            input | sliced(2, 5),
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9;
+    
+    boost::copy(
+        input | sliced(2, 5),
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 3,4,5;
 
-        std::vector<int> reference;
-        reference += 3,4,5;
+    std::vector<int> test;
+    boost::push_back(test, input | sliced(2, 5));
 
-        std::vector<int> test;
-        boost::push_back(test, input | sliced(2, 5));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/strided_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[strided_example
 #include <boost/range/adaptor/strided.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,28 +24,32 @@
 
 namespace 
 {
-    void strided_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+void strided_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9,10;
-        
-        boost::copy(
-            input | strided(2),
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9,10;
+    
+    boost::copy(
+        input | strided(2),
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 1,3,5,7,9;
 
-        std::vector<int> reference;
-        reference += 1,3,5,7,9;
+    std::vector<int> test;
+    boost::push_back(test, input | strided(2));
 
-        std::vector<int> test;
-        boost::push_back(test, input | strided(2));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/transformed_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[transformed_example
 #include <boost/range/adaptor/transformed.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -22,34 +24,40 @@
 
 namespace 
 {
-    struct double_int
-    {
-        typedef int result_type;
-        int operator()(int x) const { return x * 2; }
-    };
+//->
+struct double_int
+{
+    typedef int result_type;
+    int operator()(int x) const { return x * 2; }
+};
 
-    void transformed_example_test()
-    {
-        using namespace boost::adaptors;
-        using namespace boost::assign;
+//<-
+void transformed_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::adaptors;
+    using namespace boost::assign;
 
-        std::vector<int> input;
-        input += 1,2,3,4,5,6,7,8,9,10;
-        
-        boost::copy(
-            input | transformed(double_int()),
-            std::ostream_iterator<int>(std::cout, ","));
+    std::vector<int> input;
+    input += 1,2,3,4,5,6,7,8,9,10;
+    
+    boost::copy(
+        input | transformed(double_int()),
+        std::ostream_iterator<int>(std::cout, ","));
 
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 2,4,6,8,10,12,14,16,18,20;
 
-        std::vector<int> reference;
-        reference += 2,4,6,8,10,12,14,16,18,20;
+    std::vector<int> test;
+    boost::push_back(test, input | transformed(double_int()));
 
-        std::vector<int> test;
-        boost::push_back(test, input | transformed(double_int()));
-
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*

test/adaptor_test/type_erased_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[type_erased_example
 #include <boost/range/adaptor/type_erased.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -16,7 +17,7 @@
 #include <iostream>
 #include <list>
 #include <vector>
-
+//<-
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
@@ -26,6 +27,7 @@ namespace
     {
         namespace type_erased_example
         {
+//->            
 
 // The client interface from an OO perspective merely requires a sequence
 // of integers that can be forward traversed
@@ -99,6 +101,13 @@ namespace client
     }
 }
 
+//=int main(int argc, const char* argv[])
+//={
+//=    client::run();
+//=    return 0;
+//=}
+//]
+
         } // namespace type_erased_example
     } // namespace boost_range_test
 } // anonymous namespace

test/adaptor_test/uniqued_example.cpp

@@ -8,6 +8,7 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+//[uniqued_example
 #include <boost/range/adaptor/uniqued.hpp>
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
@@ -15,6 +16,7 @@
 #include <iostream>
 #include <vector>
 
+//<-
 #include <boost/range/algorithm_ext/push_back.hpp>
 
 #include <boost/test/test_tools.hpp>
@@ -22,27 +24,32 @@
 
 namespace
 {
-    void uniqued_example_test()
-    {
-        using namespace boost::assign;
-        using namespace boost::adaptors;
+void uniqued_example_test()
+//->
+//=int main(int argc, const char* argv[])
+{
+    using namespace boost::assign;
+    using namespace boost::adaptors;
 
-        std::vector<int> input;
-        input += 1,1,2,2,2,3,4,5,6;
+    std::vector<int> input;
+    input += 1,1,2,2,2,3,4,5,6;
 
-        boost::copy(
-            input | uniqued,
-            std::ostream_iterator<int>(std::cout, ","));
+    boost::copy(
+        input | uniqued,
+        std::ostream_iterator<int>(std::cout, ","));
 
-        std::vector<int> reference;
-        reference += 1,2,3,4,5,6;
+//=    return 0;
+//=}
+//]
+    std::vector<int> reference;
+    reference += 1,2,3,4,5,6;
 
-        std::vector<int> test;
-        boost::push_back( test, input | uniqued );
+    std::vector<int> test;
+    boost::push_back( test, input | uniqued );
 
-        BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
-            test.begin(), test.end() );
-    }
+    BOOST_CHECK_EQUAL_COLLECTIONS( reference.begin(), reference.end(),
+        test.begin(), test.end() );
+}
 }
 
 boost::unit_test::test_suite*