boost_range 0.1.0

Boost C++ library boost_range packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

    //  Copyright Neil Groves 2013. Use, modification and 
    //  distribution is subject to the Boost Software License, Version 
    //  1.0. (See accompanying file LICENSE_1_0.txt or copy at 
    //  http://www.boost.org/LICENSE_1_0.txt) 
    // 
    // 
    // For more information, see http://www.boost.org/libs/range/ 
    // 
    // Acknowledgments:
    // Implemented by Andy in response to Ticket 6888 - unique fix
    //
    #ifndef BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED 
    #define BOOST_RANGE_TEST_TEST_DRIVER_RANGE_OVERLOAD_TEST_DRIVER_HPP_INCLUDED 
     
    #include "range_return_test_driver.hpp" 
    #include <boost/assert.hpp> 
    #include <boost/test/test_tools.hpp> 
    #include <boost/test/unit_test.hpp> 
     
    namespace boost 
    { 
        namespace range_test 
        { 
             
            // A test driver to exercise a test through range_return_test_driver 
            // plus the overload that determines the return_type by overload 
            // 
            // The test driver also contains the code required to check the 
            // return value correctness. 
            // 
            // The TestPolicy needs to implement all those required by  
            // range_return_test_driver, and additionally 
            // 
            // - perform the boost range version of the algorithm that determines 
            //   the return_type by overload 
            class range_overload_test_driver : range_return_test_driver 
            { 
            public: 
                template< class Container, 
                          class TestPolicy > 
                void operator()(Container& cont, TestPolicy policy) 
                { 
                    range_return_test_driver::operator()(cont, policy); 
                    test_range_overload<Container, TestPolicy>()(cont, policy); 
                } 
     
            private: 
                template< class Container, class TestPolicy > 
                struct test_range_overload 
                { 
                    void operator()(Container& cont, TestPolicy policy) 
                    { 
                        typedef BOOST_DEDUCED_TYPENAME range_iterator<Container>::type iterator_t; 
                        typedef BOOST_DEDUCED_TYPENAME TestPolicy::template test_range_overload<Container> test_range_overload_t; 
                        const range_return_value result_type = test_range_overload_t::result_type;  
                        typedef BOOST_DEDUCED_TYPENAME range_return<Container, result_type>::type range_return_t; 
     
                        Container reference(cont); 
                        Container test_cont(cont); 
     
                        test_range_overload_t test_range_overload_fn; 
                        range_return_t range_result = test_range_overload_fn(policy, test_cont); 
     
                        iterator_t reference_it = policy.reference(reference); 
     
                        check_results<result_type>::test(test_cont, reference, 
                                                         range_result, reference_it); 
                    } 
                }; 
            }; 
        } 
    } 
     
    #endif // include guard