Merge branch 'develop'

doc/.gitignore

@@ -0,0 +1 @@
+*.html

doc/reference/algorithm_ext/insert.qbk

@@ -11,10 +11,18 @@
 template<
     class Container,
     class SinglePassRange
-    >
+>
 Container& insert(Container& target,
                   typename Container::iterator before,
                   const SinglePassRange& from);
+
+// This overload is for target containers that do not require an insertion
+// position e.g. set/map
+template<
+    class Container,
+    class SinglePassRange
+>
+Container& insert(Container& target, const SinglePassRange& from);
 ``
 
 [heading Description]

doc/reference/algorithms.qbk

@@ -37,7 +37,9 @@ boost::copy(boost::unique(boost::sort(vec)),
             std::ostream_iterator<int>(std::cout));
 ``
 
-Algorithms like `boost::unique` usually return the same range: `[boost::begin(rng), found)`. However, this behaviour may be changed by supplying the algorithms with a template argument:
+Algorithms like `boost::unique` usually return the range: `[boost::begin(rng), found)`.
+However, this behaviour may be changed by supplying a `range_return_value`
+as a template parameter to the algorithm:
 
 [table
     [[Expression] [Return]]
@@ -177,4 +179,4 @@ and there is no need to worry about generating an invalid range. Furthermore, if
 [include numeric/inner_product.qbk]
 [include numeric/partial_sum.qbk]
 [endsect]
-[endsect]
+[endsect]

doc/reference/utilities.qbk

@@ -9,6 +9,7 @@ Having an abstraction that encapsulates a pair of iterators is very useful. The
 
 * Class `iterator_range`
 * Class `sub_range`
+* Function `combine`
 * Function `join`
 
 The `iterator_range` class is templated on an __forward_traversal_iterator__ and should be used whenever fairly general code is needed. The `sub_range` class is templated on an __forward_range__ and it is less general, but a bit easier to use since its template argument is easier to specify. The biggest difference is, however, that a `sub_range` can propagate constness because it knows what a corresponding `const_iterator` is.
@@ -26,6 +27,14 @@ Recall that many default constructed iterators are [*/singular/] and hence can o
 
 [h4 Synopsis]
 
+The core functionality is in the header file
+`<boost/range/iterator_range_core.hpp>` this includes all of the functionality
+except the `boost::hash_value` and `std::iostream` support.
+
+The `std::iostream` support is in the header `<boost/range/iterator_core.hpp>`
+while the `boost::hash_value` support is in
+`<boost/range/iterator_range_hash.hpp>`
+
 ``
 namespace boost
 {
@@ -273,6 +282,83 @@ sub_range<std::string>               sub = find_first( str, "ll" );
 
 [endsect]
 
+[section:combine Function combine]
+
+The `combine` function is used to make one range from multiple ranges. The
+`combine` function returns a `combined_range` which is an `iterator_range` of
+a `zip_iterator` from the Boost.Iterator library.
+
+[h4 Synopsis]
+
+``
+namespace boost
+{
+    namespace range
+    {
+
+template<typename IterTuple>
+class combined_range
+    : public iterator_range<zip_iterator<IterTuple> >
+{
+public:
+    combined_range(IterTuple first, IterTuple last);
+};
+
+template<typename... Ranges>
+auto combine(Ranges&&... rngs) ->
+    combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>
+
+    } // namespace range
+} // namespace boost
+``
+
+* [*Precondition:] For each type `r` in `Ranges`, `r` is a model of
+__single_pass_range__ or better.
+* [*Return Type:] `combined_range<tuple<typename range_iterator<Ranges>::type...> >`
+* [*Returned Range Category:] The minimum of the range category of every range
+`r` in `Ranges`.
+
+[h4 Example]
+
+``
+#include <boost/range/combine.hpp>
+#include <boost/foreach.hpp>
+#include <iostream>
+#include <vector>
+#include <list>
+
+int main(int, const char*[])
+{
+    std::vector<int> v;
+    std::list<char> l;
+    for (int i = 0; i < 5; ++i)
+    {
+        v.push_back(i);
+        l.push_back(static_cast<char>(i) + 'a');
+    }
+
+    int ti;
+    char tc;
+    BOOST_FOREACH(boost::tie(ti, tc), boost::combine(v, l))
+    {
+        std::cout << '(' << ti << ',' << tv << ')' << '\n';
+    }
+
+    return 0;
+}
+``
+
+This produces the output:
+``
+(0,a)
+(1,b)
+(2,c)
+(3,d)
+(4,e)
+``
+
+[endsect]
+
 [section:join Function join]
 
 The intention of the `join` function is to join two ranges into one longer range.

doc/upgrade.qbk

@@ -16,6 +16,8 @@ been noted that some calling code was relying on member functions such as
 due to `iterator_reference<Iter>::type` not being a reference. The suggested
 refactoring is to use `boost::size(rng)`.
 
+[endsect]
+
 [section:upgrade_from_1_49 Upgrade from version 1.49]
 
 # __size__ now returns the type Rng::size_type if the range has size_type;

include/boost/range/algorithm_ext/insert.hpp

@@ -29,12 +29,18 @@ inline Container& insert( Container& on,
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
-    BOOST_ASSERT( (void*)&on != (void*)&from &&
-                  "cannot copy from a container to itself" );
     on.insert( before, boost::begin(from), boost::end(from) );
     return on;
 }
 
+template< class Container, class Range >
+inline Container& insert( Container& on, const Range& from )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<Container> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<Range> ));
+    on.insert(boost::begin(from), boost::end(from));
+}
+
     } // namespace range
     using range::insert;
 } // namespace boost

include/boost/range/any_range.hpp

@@ -75,8 +75,8 @@ namespace boost
         template<
             class Value
           , class Traversal
-          , class Reference
+          , class Reference = Value&
-          , class Difference
+          , class Difference = std::ptrdiff_t
           , class Buffer = use_default
         >
         class any_range

include/boost/range/combine.hpp

@@ -9,296 +9,37 @@
 #ifndef BOOST_RANGE_COMBINE_HPP
 #define BOOST_RANGE_COMBINE_HPP
 
-#include <boost/iterator/zip_iterator.hpp>
-#include <boost/tuple/tuple.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/iterator_range.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/mpl/plus.hpp>
-#include <boost/mpl/arithmetic.hpp>
 #include <boost/config.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/iterator/zip_iterator.hpp>
 
 namespace boost
 {
-    namespace range_detail
+    namespace range
+    {
+
+template<typename IterTuple>
+class combined_range
+        : public iterator_range<zip_iterator<IterTuple> >
+{
+    typedef iterator_range<zip_iterator<IterTuple> > base;
+public:
+    combined_range(IterTuple first, IterTuple last)
+        : base(first, last)
     {
-        struct void_ { typedef void_ type; };
-    }
-
-    template<> struct range_iterator< ::boost::range_detail::void_ >
-    {
-       typedef ::boost::tuples::null_type type;
-    };
-
-    namespace range_detail
-    {
-        inline ::boost::tuples::null_type range_begin( ::boost::range_detail::void_& )
-        { return ::boost::tuples::null_type(); }
-
-        inline ::boost::tuples::null_type range_begin( const ::boost::range_detail::void_& )
-        { return ::boost::tuples::null_type(); }
-
-        inline ::boost::tuples::null_type range_end( ::boost::range_detail::void_& )
-        { return ::boost::tuples::null_type(); }
-
-        inline ::boost::tuples::null_type range_end( const ::boost::range_detail::void_& )
-        { return ::boost::tuples::null_type(); }
-
-        template< class T >
-        struct tuple_iter
-        {
-            typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
-                ::boost::is_same<T, ::boost::range_detail::void_ >::value,
-                ::boost::mpl::identity< ::boost::tuples::null_type >,
-                ::boost::range_iterator<T>
-            >::type type;
-        };
-
-        template< class Rng1, class Rng2 >
-        struct tuple_range
-        {
-            typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
-                ::boost::is_same<Rng1, ::boost::range_detail::void_ >::value,
-                ::boost::range_detail::void_,
-                ::boost::mpl::identity<Rng1>
-            >::type type;
-        };
-
-        template
-        <
-            class R1,
-            class R2,
-            class R3,
-            class R4,
-            class R5,
-            class R6
-        >
-        struct generate_tuple
-        {
-            typedef ::boost::tuples::tuple<
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R1>::type,
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R2>::type,
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R3>::type,
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R4>::type,
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R5>::type,
-                        BOOST_DEDUCED_TYPENAME tuple_iter<R6>::type
-                    > type;
-
-            static type begin( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
-            {
-                return ::boost::tuples::make_tuple( ::boost::begin(r1),
-                                                    ::boost::begin(r2),
-                                                    ::boost::begin(r3),
-                                                    ::boost::begin(r4),
-                                                    ::boost::begin(r5),
-                                                    ::boost::begin(r6) );
-            }
-
-            static type end( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
-            {
-                return ::boost::tuples::make_tuple( ::boost::end(r1),
-                                                    ::boost::end(r2),
-                                                    ::boost::end(r3),
-                                                    ::boost::end(r4),
-                                                    ::boost::end(r5),
-                                                    ::boost::end(r6) );
-            }
-        };
-
-        template
-        <
-            class R1,
-            class R2 = void_,
-            class R3 = void_,
-            class R4 = void_,
-            class R5 = void_,
-            class R6 = void_
-        >
-        struct zip_rng
-            : iterator_range<
-                zip_iterator<
-                    BOOST_DEDUCED_TYPENAME generate_tuple<R1,R2,R3,R4,R5,R6>::type
-                >
-            >
-        {
-        private:
-            typedef generate_tuple<R1,R2,R3,R4,R5,R6>        generator_t;
-            typedef BOOST_DEDUCED_TYPENAME generator_t::type tuple_t;
-            typedef zip_iterator<tuple_t>                    zip_iter_t;
-            typedef iterator_range<zip_iter_t>               base_t;
-
-        public:
-            zip_rng( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
-            : base_t( zip_iter_t( generator_t::begin(r1,r2,r3,r4,r5,r6) ),
-                      zip_iter_t( generator_t::end(r1,r2,r3,r4,r5,r6) ) )
-            {
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r4));
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r5));
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r6));
-            }
-
-            template< class Zip, class Rng >
-            zip_rng( Zip& z, Rng& r )
-            : base_t( zip_iter_t( generator_t::begin( z, r ) ),
-                      zip_iter_t( generator_t::end( z, r ) ) )
-            {
-
-                // @todo: tuple::begin( should be overloaded for this situation
-            }
-
-            struct tuple_length : ::boost::tuples::length<tuple_t>
-            { };
-
-            template< unsigned N >
-            struct get
-            {
-                template< class Z, class R >
-                static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type begin( Z& z, R& )
-                {
-                    return get<N>( z.begin().get_iterator_tuple() );
-                }
-
-                template< class Z, class R >
-                static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type end( Z& z, R& r )
-                {
-                    return get<N>( z.end().get_iterator_tuple() );
-                }
-            };
-
-        };
-
-        template< class Rng1, class Rng2 >
-        struct zip_range
-            : iterator_range<
-                zip_iterator<
-                    ::boost::tuples::tuple<
-                        BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
-                        BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
-                    >
-                >
-            >
-        {
-        private:
-            typedef zip_iterator<
-                        ::boost::tuples::tuple<
-                            BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
-                            BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
-                        >
-                    > zip_iter_t;
-            typedef iterator_range<zip_iter_t> base_t;
-
-        public:
-            zip_range( Rng1& r1, Rng2& r2 )
-            : base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
-                                                              ::boost::begin(r2)) ),
-                      zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
-                                                              ::boost::end(r2)) ) )
-            {
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
-            }
-        };
-
-        template< class Rng1, class Rng2, class Rng3 >
-        struct zip_range3
-            : iterator_range<
-                zip_iterator<
-                    ::boost::tuples::tuple<
-                        BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
-                        BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
-                        BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
-                    >
-                >
-            >
-        {
-        private:
-            typedef zip_iterator<
-                ::boost::tuples::tuple<
-                    BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
-                    BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
-                    BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
-                >
-            > zip_iter_t;
-            typedef iterator_range<zip_iter_t> base_t;
-
-        public:
-            zip_range3( Rng1& r1, Rng2& r2, Rng3& r3 )
-            : base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
-                                                              ::boost::begin(r2),
-                                                              ::boost::begin(r3)) ),
-                      zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
-                                                              ::boost::end(r2),
-                                                              ::boost::end(r3)) )
-                    )
-            {
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
-                BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
-            }
-        };
-
-
-        struct combine_tag {};
-
-        template< class Rng >
-        inline zip_rng<Rng>
-        operator&( combine_tag, Rng& r )
-        {
-            return zip_rng<Rng>(r);
-        }
-
-        template< class Rng >
-        inline iterator_range<const Rng>
-        operator&( combine_tag, const Rng& r )
-        {
-            return iterator_range<const Rng>(r);
-        }
-
-        template
-        <
-            class R1,
-            class R2,
-            class R3,
-            class R4,
-            class R5,
-            class Rng
-        >
-        inline BOOST_DEDUCED_TYPENAME zip_rng<R1,R2,R3,R4,R5>::next
-        operator&( const zip_rng<R1,R2,R3,R4,R5>& zip,
-                   Rng& r )
-        {
-            return zip_rng<R1,R2,R3,R4,R5>::next( zip, r );
-        }
-
-    } // namespace range_detail
-
-    template< class Rng1, class Rng2 >
-    inline ::boost::range_detail::zip_range<Rng1, Rng2> combine( Rng1& r1, Rng2& r2 )
-    {
-        return ::boost::range_detail::zip_range<Rng1, Rng2>(r1, r2);
-    }
-
-    template< class Rng1, class Rng2 >
-    inline ::boost::range_detail::zip_range<const Rng1, Rng2> combine( const Rng1& r1, Rng2& r2 )
-    {
-        return ::boost::range_detail::zip_range<const Rng1, Rng2>(r1, r2);
-    }
-
-    template< class Rng1, class Rng2 >
-    inline ::boost::range_detail::zip_range<Rng1, const Rng2> combine( Rng1& r1, const Rng2& r2 )
-    {
-        return ::boost::range_detail::zip_range<Rng1, const Rng2>(r1, r2);
-    }
-
-    template< class Rng1, class Rng2 >
-    inline ::boost::range_detail::zip_range<const Rng1, const Rng2> combine( const Rng1& r1, const Rng2& r2 )
-    {
-        return ::boost::range_detail::zip_range<const Rng1, const Rng2>(r1, r2);
     }
+};
 
+    } // namespace range
 } // namespace boost
 
+#if defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) || \
+    defined(BOOST_NO_CXX11_DECLTYPE) || \
+    defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
+    defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#   include <boost/range/detail/combine_cxx03.hpp>
+#else
+#   include <boost/range/detail/combine_cxx11.hpp>
+#endif
+
 #endif

include/boost/range/concepts.hpp

@@ -72,6 +72,13 @@ namespace boost {
         #endif
     #endif
 
+    #ifdef __GCCXML__
+        // GCC XML, unsurprisingly, has the same issues
+        #if __GCCXML_GNUC__ == 4 && __GCCXML_GNUC_MINOR__ == 2
+            #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
+        #endif
+    #endif
+
     #ifdef __BORLANDC__
         #define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
     #endif

include/boost/range/const_iterator.hpp

@@ -20,6 +20,7 @@
 
 #include <boost/range/detail/extract_optional_type.hpp>
 #include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <cstddef>
 #include <utility>
 
@@ -29,33 +30,45 @@ namespace boost
     // default
     //////////////////////////////////////////////////////////////////////////
     
-    namespace range_detail {
+    namespace range_detail
-        BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
-    }
-
-    template< typename C >
-    struct range_const_iterator : range_detail::extract_const_iterator<C>
-    {};
-    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_const_iterator< std::pair<Iterator,Iterator> >
     {
-        typedef Iterator type;
-    };
-    
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
 
-    template< typename T, std::size_t sz >
+BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
-    struct range_const_iterator< T[sz] >
+
-    {
+template< typename C >
-        typedef const T* type;
+struct range_const_iterator
-    };
+        : extract_const_iterator<C>
+{};
+
+//////////////////////////////////////////////////////////////////////////
+// pair
+//////////////////////////////////////////////////////////////////////////
+
+template< typename Iterator >
+struct range_const_iterator<std::pair<Iterator,Iterator> >
+{
+    typedef Iterator type;
+};
+
+//////////////////////////////////////////////////////////////////////////
+// array
+//////////////////////////////////////////////////////////////////////////
+
+template< typename T, std::size_t sz >
+struct range_const_iterator< T[sz] >
+{
+    typedef const T* type;
+};
+
+    } // namespace range_detail
+
+template<typename C>
+struct range_const_iterator
+        : range_detail::range_const_iterator<
+            BOOST_DEDUCED_TYPENAME remove_reference<C>::type
+        >
+{
+};
 
 } // namespace boost
 

include/boost/range/const_reverse_iterator.hpp

@@ -16,6 +16,7 @@
 #endif
 
 #include <boost/range/reverse_iterator.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 namespace boost
 {
@@ -24,7 +25,9 @@ namespace boost
     //
     
     template< typename C >
-    struct range_const_reverse_iterator : range_reverse_iterator<const C>
+    struct range_const_reverse_iterator
+            : range_reverse_iterator<
+                const BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
     { };
     
 } // namespace boost

include/boost/range/detail/combine_cxx03.hpp

@@ -0,0 +1,131 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+#ifndef BOOST_RANGE_DETAIL_COMBINE_CXX03_HPP
+#define BOOST_RANGE_DETAIL_COMBINE_CXX03_HPP
+
+#ifndef BOOST_RANGE_MIN_COMBINE_ARGS
+#define BOOST_RANGE_MIN_COMBINE_ARGS 2
+#endif
+
+#ifndef BOOST_RANGE_MAX_COMBINE_ARGS
+#define BOOST_RANGE_MAX_COMBINE_ARGS 5
+#endif
+
+#include <boost/config.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/preprocessor/arithmetic/dec.hpp>
+#include <boost/preprocessor/arithmetic/div.hpp>
+#include <boost/preprocessor/arithmetic/mul.hpp>
+#include <boost/preprocessor/control.hpp>
+#include <boost/preprocessor/control/while.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+#include <boost/preprocessor/facilities/identity.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+#include <boost/preprocessor/punctuation/comma.hpp>
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/utility/result_of.hpp>
+
+#include <vector>
+#include <list>
+
+namespace boost
+{
+    namespace range_detail
+    {
+
+template<typename F, typename T, int SIZE>
+struct combined_result_impl;
+
+template<typename F, typename T>
+struct combined_result
+    : combined_result_impl<F, T, tuples::length<T>::value>
+{
+};
+
+#define BOOST_RANGE_combined_element(z, n, data) \
+    typename tuples::element<n, T>::type
+
+#define BOOST_RANGE_combined_result(z, n, data) \
+    template<typename F, typename T> \
+    struct combined_result_impl <F,T,n> \
+        : result_of<F(BOOST_PP_ENUM(n, BOOST_RANGE_combined_element, ~))> \
+    { \
+    };
+
+#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combined_result(~,n,~)
+
+#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
+                               BOOST_RANGE_MAX_COMBINE_ARGS)
+#include BOOST_PP_LOCAL_ITERATE()
+
+#define BOOST_RANGE_combined_get(z, n, data) get<n>(tuple)
+
+#define BOOST_RANGE_combined_unpack(z, n, data) \
+    template<typename F, typename T> inline \
+    typename combined_result<F,T>::type \
+    unpack_(mpl::int_<n>, F f, const T& tuple) \
+    { \
+        return f(BOOST_PP_ENUM(n, BOOST_RANGE_combined_get, ~)); \
+    }
+
+#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combined_unpack(~,n,~)
+#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
+                               BOOST_RANGE_MAX_COMBINE_ARGS)
+#include BOOST_PP_LOCAL_ITERATE()
+
+} // namespace range_detail
+
+namespace range
+{
+
+#define BOOST_RANGE_combined_seq(z, n, data) boost::data(BOOST_PP_CAT(r,n))
+
+#ifdef BOOST_NO_RVALUE_REFERENCES
+
+#include <boost/range/detail/combine_no_rvalue.hpp>
+
+#else // by using rvalue references we avoid requiring 2^n overloads.
+
+#include <boost/range/detail/combine_rvalue.hpp>
+
+#endif
+
+#define BOOST_PP_LOCAL_MACRO(n) BOOST_RANGE_combine(~,n,~)
+#define BOOST_PP_LOCAL_LIMITS (BOOST_RANGE_MIN_COMBINE_ARGS, \
+                               BOOST_RANGE_MAX_COMBINE_ARGS)
+#include BOOST_PP_LOCAL_ITERATE()
+
+    } // namespace range
+
+    using boost::range::combine;
+
+} // namespace boost
+
+#endif // include guard
+
+#undef BOOST_RANGE_combined_element
+#undef BOOST_RANGE_combined_result
+#undef BOOST_RANGE_combined_get
+#undef BOOST_RANGE_combined_unpack
+#undef BOOST_RANGE_combined_seq
+#undef BOOST_RANGE_combined_exp_pred
+#undef BOOST_RANGE_combined_exp_op
+#undef BOOST_RANGE_combined_exp
+#undef BOOST_RANGE_combined_bitset_pred
+#undef BOOST_RANGE_combined_bitset_op
+#undef BOOST_RANGE_combined_bitset
+#undef BOOST_RANGE_combined_range_iterator
+#undef BOOST_RANGE_combined_args
+#undef BOOST_RANGE_combine_impl
+#undef BOOST_RANGE_combine

include/boost/range/detail/combine_cxx11.hpp

@@ -0,0 +1,40 @@
+//  Copyright Neil Groves 2014. 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/
+//
+#ifndef BOOST_RANGE_DETAIL_COMBINE_CXX11_HPP
+#define BOOST_RANGE_DETAIL_COMBINE_CXX11_HPP
+
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+
+#include <fstream>
+
+namespace boost
+{
+    namespace range
+    {
+
+template<typename... Ranges>
+auto combine(Ranges&&... rngs) ->
+    combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>
+{
+    return combined_range<decltype(boost::make_tuple(boost::begin(rngs)...))>(
+                boost::make_tuple(boost::begin(rngs)...),
+                boost::make_tuple(boost::end(rngs)...));
+}
+
+    } // namespace range
+
+using range::combine;
+
+} // namespace boost
+
+#endif // include guard

include/boost/range/detail/combine_no_rvalue.hpp

@@ -0,0 +1,73 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+#define BOOST_RANGE_combined_exp_pred(d, data) BOOST_PP_TUPLE_ELEM(3, 0, data)
+
+#define BOOST_RANGE_combined_exp_op(d, data) \
+ ( \
+    BOOST_PP_DEC( \
+       BOOST_PP_TUPLE_ELEM(3, 0, data) \
+    ), \
+    BOOST_PP_TUPLE_ELEM(3, 1, data), \
+    BOOST_PP_MUL_D( \
+       d, \
+       BOOST_PP_TUPLE_ELEM(3, 2, data), \
+       BOOST_PP_TUPLE_ELEM(3, 1, data) \
+    ) \
+ )
+
+#define BOOST_RANGE_combined_exp(x, n) \
+  BOOST_PP_TUPLE_ELEM(3, 2, \
+  BOOST_PP_WHILE(BOOST_RANGE_combined_exp_pred, \
+                 BOOST_RANGE_combined_exp_op, (n, x, 1)))
+
+#define BOOST_RANGE_combined_bitset_pred(n, state) \
+    BOOST_PP_TUPLE_ELEM(2,1,state)
+
+#define BOOST_RANGE_combined_bitset_op(d, state) \
+    (BOOST_PP_DIV_D(d, BOOST_PP_TUPLE_ELEM(2,0,state), 2), \
+     BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2,1,state)))
+
+#define BOOST_RANGE_combined_bitset(i, n) \
+BOOST_PP_MOD(BOOST_PP_TUPLE_ELEM(2, 0, \
+      BOOST_PP_WHILE(BOOST_RANGE_combined_bitset_pred, \
+                     BOOST_RANGE_combined_bitset_op, (i,n))), 2)
+
+#define BOOST_RANGE_combined_range_iterator(z, n, i) \
+  typename range_iterator< \
+      BOOST_PP_CAT(R,n)          \
+      BOOST_PP_IF( \
+          BOOST_RANGE_combined_bitset(i,n), \
+          BOOST_PP_IDENTITY(const), \
+          BOOST_PP_EMPTY)() \
+  >::type
+
+#define BOOST_RANGE_combined_args(z, n, i) \
+  BOOST_PP_CAT(R, n) \
+  BOOST_PP_IF(BOOST_RANGE_combined_bitset(i,n), const&, &)  \
+  BOOST_PP_CAT(r, n)
+
+#define BOOST_RANGE_combine_impl(z, i, n)\
+    template<BOOST_PP_ENUM_PARAMS(n, typename R)> \
+    inline range::combined_range< \
+        boost::tuple<BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, i)> \
+    > \
+    combine(BOOST_PP_ENUM(n, BOOST_RANGE_combined_args, i)) \
+    { \
+        typedef tuple< \
+            BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, i) \
+        > rng_tuple_t;   \
+        return range::combined_range<rng_tuple_t>( \
+            rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, begin)), \
+            rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, end))); \
+    }
+
+
+#define BOOST_RANGE_combine(z, n, data) \
+  BOOST_PP_REPEAT(BOOST_RANGE_combined_exp(2,n), BOOST_RANGE_combine_impl, n)

include/boost/range/detail/combine_rvalue.hpp

@@ -0,0 +1,32 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+#define BOOST_RANGE_combined_args(z, n, i) \
+    BOOST_PP_CAT(R, n)&& BOOST_PP_CAT(r, n)
+
+#define BOOST_RANGE_combined_range_iterator(z, n, i) \
+    typename range_iterator< \
+        typename remove_reference<BOOST_PP_CAT(R,n)>::type \
+  >::type
+
+
+#define BOOST_RANGE_combine(z, n, data) \
+    template <BOOST_PP_ENUM_PARAMS(n, typename R)> \
+    inline range::combined_range< \
+        tuple<BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, ~)> \
+    > \
+    combine(BOOST_PP_ENUM(n, BOOST_RANGE_combined_args, ~)) \
+    { \
+        typedef tuple< \
+            BOOST_PP_ENUM(n, BOOST_RANGE_combined_range_iterator, ~) \
+        > rng_tuple_t; \
+        return range::combined_range<rng_tuple_t>( \
+            rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, begin)), \
+            rng_tuple_t(BOOST_PP_ENUM(n, BOOST_RANGE_combined_seq, end))); \
+    }

include/boost/range/difference_type.hpp

@@ -18,11 +18,17 @@
 #include <boost/range/config.hpp>
 #include <boost/range/iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 namespace boost
 {
     template< class T >
-    struct range_difference : iterator_difference< typename range_iterator<T>::type >
+    struct range_difference
+            : iterator_difference<
+                BOOST_DEDUCED_TYPENAME range_iterator<
+                    BOOST_DEDUCED_TYPENAME remove_reference<T>::type
+                >::type
+            >
     { };
 }
 

include/boost/range/has_range_iterator.hpp

@@ -17,6 +17,7 @@
 #include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/has_xxx.hpp>
 #include <boost/range/iterator.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <boost/utility/enable_if.hpp>
 
 namespace boost
@@ -67,12 +68,14 @@ namespace boost
 
     template<class T>
     struct has_range_iterator
-        : range_detail::has_range_iterator_impl<T>
+        : range_detail::has_range_iterator_impl<
+            BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
     {};
 
     template<class T>
     struct has_range_const_iterator
-        : range_detail::has_range_const_iterator_impl<T>
+        : range_detail::has_range_const_iterator_impl<
+            BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
     {};
 } // namespace boost
 

include/boost/range/iterator.hpp

@@ -57,10 +57,15 @@ namespace boost
            
 #else  
 
-        typedef BOOST_RANGE_DEDUCED_TYPENAME 
+    private:
-            mpl::eval_if_c< is_const<C>::value, 
+        typedef typename remove_reference<C>::type param_t;
-                            range_const_iterator< typename remove_const<C>::type >,
+
-                            range_mutable_iterator<C> >::type type;
+    public:
+        typedef typename mpl::eval_if_c<
+            is_const<param_t>::value,
+            range_const_iterator<typename remove_const<param_t>::type>,
+            range_mutable_iterator<param_t>
+        >::type type;
         
 #endif         
     };

include/boost/range/iterator_range_core.hpp

@@ -7,6 +7,10 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
+// Credits:
+// 'michel' reported Trac 9072 which included a patch for allowing references
+// to function types.
+//
 #ifndef BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
 #define BOOST_RANGE_ITERATOR_RANGE_CORE_HPP_INCLUDED
 
@@ -25,6 +29,7 @@
 #include <boost/type_traits/is_abstract.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_function.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/range/functions.hpp>
@@ -300,6 +305,9 @@ public:
                 >,
                 boost::is_array<
                     BOOST_DEDUCED_TYPENAME base_type::value_type
+                >,
+                boost::is_function<
+                    BOOST_DEDUCED_TYPENAME base_type::value_type
                 >
             >,
             BOOST_DEDUCED_TYPENAME base_type::reference,

include/boost/range/iterator_range_hash.hpp

@@ -0,0 +1,22 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014
+//  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/
+//
+#include <boost/range/iterator_range_core.hpp>
+#include <boost/functional/hash.hpp>
+
+namespace boost
+{
+
+template<class T>
+std::size_t hash_value(const iterator_range<T>& rng)
+{
+    return boost::hash_range(rng.begin(), rng.end());
+}
+
+} // namespace boost

include/boost/range/mutable_iterator.hpp

@@ -19,12 +19,14 @@
 
 
 #include <boost/range/detail/extract_optional_type.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <cstddef>
 #include <utility>
 
 namespace boost
 {
+
     //////////////////////////////////////////////////////////////////////////
     // default
     //////////////////////////////////////////////////////////////////////////
@@ -34,7 +36,9 @@ namespace boost
     }
 
     template< typename C >
-    struct range_mutable_iterator : range_detail::extract_iterator<C>
+    struct range_mutable_iterator
+            : range_detail::extract_iterator<
+                BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
     {};
     
     //////////////////////////////////////////////////////////////////////////

include/boost/range/pointer.hpp

@@ -22,7 +22,8 @@
 namespace boost
 {
     template< class T >
-    struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
+    struct range_pointer
+            : iterator_pointer< BOOST_DEDUCED_TYPENAME range_iterator<T>::type >
     { };
 }
 

include/boost/range/reverse_iterator.hpp

@@ -17,6 +17,7 @@
 
 #include <boost/range/config.hpp>
 #include <boost/range/iterator.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 
 
@@ -30,7 +31,8 @@ namespace boost
     struct range_reverse_iterator
     {
         typedef reverse_iterator< 
-            BOOST_DEDUCED_TYPENAME range_iterator<C>::type > type;
+            BOOST_DEDUCED_TYPENAME range_iterator<
+                BOOST_DEDUCED_TYPENAME remove_reference<C>::type>::type > type;
     };
     
 

test/Jamfile.v2

@@ -147,26 +147,39 @@ test-suite range :
     [ range-test array ]
 #    [ range-test atl : <include>$(VC71_ROOT)/atlmfc/include ]
     [ range-test begin ]
+    [ range-test category ]
     [ range-test combine ]
     [ range-test compat2 ]
     [ range-test compat3 ]
+    [ range-test const_iterator ]
     [ range-test const_ranges ]
+    [ range-test const_reverse_iterator ]
     [ range-test counting_range ]
+    [ range-test difference_type ]
     [ range-test end ]
     [ range-test extension_mechanism ]
     [ range-test extension_size ]
     [ range-test has_range_iterator ]
     [ range-test irange ]
     [ range-test istream_range ]
+    [ range-test iterator ]
     [ range-test iterator_pair ]
     [ range-test iterator_range ]
     [ range-test iterator_range_drop ]
+    [ range-test iterator_range_hash ]
     [ range-test iterator_range_variant ]
 #       [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ]
     [ range-test join ]
+    [ range-test mutable_iterator ]
     [ range-test partial_workaround ]
+    [ range-test pointer ]
     [ range-test pointer_as_iterator ]
+    [ range-test reference ]
+    [ range-test result_iterator ]
+    [ range-test reverse_iterator ]
+    [ range-test reverse_result_iterator ]
     [ range-test reversible_range ]
+    [ range-test size_type ]
     [ range-test std_container ]
     [ range-test string ]
     [ range-test sub_range ]
@@ -177,5 +190,6 @@ test-suite range :
     [ range-test ticket_5811_indirected_optional ]
     [ range-test ticket_6715_iterator_range_equality ]
     [ range-test ticket_6944 ]
+    [ range-test value_type ]
     ;
 

test/category.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/category.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_category()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::iterator_category<cont::const_iterator>::type,
+            boost::range_category<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::iterator_category<cont::const_iterator>::type,
+            boost::range_category<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::iterator_category<cont::const_iterator>::type,
+            boost::range_category<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_category meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_category));
+
+    return test;
+}

test/combine.cpp

@@ -1,5 +1,7 @@
 // Boost.Range library
 //
+// Copyright Neil Groves 2014
+//
 //  Copyright Thorsten Ottosen 2006. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -7,65 +9,152 @@
 //
 // For more information, see http://www.boost.org/libs/range/
 //
-
 #include <boost/range/combine.hpp>
+
+#include <boost/range/algorithm_ext/push_back.hpp>
+
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
-#include <boost/tuple/tuple.hpp>
 #include <boost/foreach.hpp>
 #include <vector>
 
-
+namespace boost_range_test
-struct add
 {
-    template< class T >
+    namespace
-    int operator()( const T& tuple ) const
     {
-        return boost::get<0>(tuple) + boost::get<1>(tuple);
-    }
-};
 
-template< class CombinedRng >
+template<typename ContRef1, typename ContRef2>
-void apply( const CombinedRng& r )
+void test_combine2()
 {
     std::vector<int> v;
-    typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<const CombinedRng>::type iterator_t;
+    std::list<int> l;
 
-    iterator_t e = boost::end(r);
+    for (int i = 0; i < 10; ++i)
-    for (iterator_t i = boost::begin(r); i != e; ++i)
     {
+        v.push_back(i);
+        l.push_back(i * 2);
+    }
+
+    ContRef1& in1 = v;
+    ContRef2& in2 = l;
+
+    std::vector<boost::tuple<int,int> > output;
+    boost::push_back(output, boost::combine(in1, in2));
+
+    int index = 0;
+    int i1, i2;
+    BOOST_FOREACH(boost::tie(i1,i2), output)
+    {
+        BOOST_CHECK_EQUAL(i1, index);
+        BOOST_CHECK_EQUAL(i2, index * 2);
+        ++index;
     }
 }
 
-void test_combine()
+template<typename ContRef1, typename ContRef2, typename ContRef3>
+void test_combine3()
 {
-    std::vector<int> v1, v2, v3;
+    std::vector<int> v1;
-    for (int i = 1; i <= 4; ++i)
+    std::vector<int> v2;
+    std::vector<int> v3;
+
+    for (int i = 0; i < 10; ++i)
     {
         v1.push_back(i);
-        v2.push_back(i);
+        v2.push_back(i * 2);
+        v3.push_back(i * 3);
     }
 
-    int i1, i2;
+    ContRef1& in1 = v1;
-    BOOST_FOREACH( boost::tie( i1, i2 ), boost::combine(v1,v2) )
+    ContRef2& in2 = v2;
+    ContRef3& in3 = v3;
+
+    std::vector<boost::tuple<int,int,int> > output;
+    boost::push_back(output, boost::combine(in1, in2, in3));
+
+    int index = 0;
+    int i1, i2, i3;
+
+    BOOST_FOREACH(boost::tie(i1,i2,i3), output)
     {
-        v3.push_back( i1 + i2 );
+        BOOST_CHECK_EQUAL(i1, index);
+        BOOST_CHECK_EQUAL(i2, index * 2);
+        BOOST_CHECK_EQUAL(i3, index * 3);
+        ++index;
     }
-
-    BOOST_CHECK_EQUAL( v3.size(), v1.size() );
 }
 
+    } // anonymous namespace
+} // namespace boost_range_test
 
-
+boost::unit_test::test_suite* init_unit_test_suite(int, char*[] )
-using boost::unit_test::test_suite;
-
-test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test =
+            BOOST_TEST_SUITE( "Boost.Range combine() test suite" );
 
-    test->add( BOOST_TEST_CASE( &test_combine ) );
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine2<
+                        const std::vector<int>, const std::list<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine2<
+                        const std::vector<int>, std::list<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine2<
+                        std::vector<int>, const std::list<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine2<
+                        std::vector<int>, std::list<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        std::vector<int>,
+                        std::vector<int>,
+                        std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        std::vector<int>,
+                        std::vector<int>,
+                        const std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        std::vector<int>,
+                        const std::vector<int>,
+                        std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        std::vector<int>,
+                        const std::vector<int>,
+                        const std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        const std::vector<int>,
+                        std::vector<int>,
+                        std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        const std::vector<int>,
+                        std::vector<int>,
+                        const std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        const std::vector<int>,
+                        const std::vector<int>,
+                        std::vector<int> >)));
+
+    test->add(BOOST_TEST_CASE((
+            &boost_range_test::test_combine3<
+                        const std::vector<int>,
+                        const std::vector<int>,
+                        const std::vector<int> >)));
 
     return test;
 }
-
-

test/const_iterator.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/const_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_const_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_iterator,
+            boost::range_const_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_iterator,
+            boost::range_const_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_iterator,
+            boost::range_const_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_const_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_const_iterator));
+
+    return test;
+}

test/const_reverse_iterator.cpp

@@ -0,0 +1,62 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/const_reverse_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_const_reverse_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::const_iterator>,
+            boost::range_const_reverse_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::const_iterator>,
+            boost::range_const_reverse_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::const_iterator>,
+            boost::range_const_reverse_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE(
+                "Boost.Range range_const_reverse_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_const_reverse_iterator));
+
+    return test;
+}

test/difference_type.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/difference_type.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_difference()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::difference_type,
+            boost::range_difference<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::difference_type,
+            boost::range_difference<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::difference_type,
+            boost::range_difference<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_difference meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_difference));
+
+    return test;
+}

test/has_range_iterator.cpp

@@ -9,6 +9,7 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 #include <boost/range/has_range_iterator.hpp>
+#include <boost/config.hpp>
 
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
@@ -35,12 +36,22 @@ namespace
     {
         test_has_range_iterator_impl< std::vector<int> >(true);
         test_has_range_iterator_impl< MockClassWithoutIterators >(false);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+        test_has_range_iterator_impl<std::vector<int>&&>(true);
+        test_has_range_iterator_impl<MockClassWithoutIterators&&>(false);
+#endif
     }
 
     void test_has_range_const_iterator()
     {
         test_has_range_const_iterator_impl< std::vector<int> >(true);
         test_has_range_const_iterator_impl< MockClassWithoutIterators >(false);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+        test_has_range_const_iterator_impl<std::vector<int>&&>(true);
+        test_has_range_const_iterator_impl<MockClassWithoutIterators&&>(false);
+#endif
     }
 }
 

test/iterator.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_iterator,
+            boost::range_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_iterator));
+
+    return test;
+}

test/iterator_range_hash.cpp

@@ -0,0 +1,52 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/iterator_range_hash.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_iterator_range_hash()
+{
+    std::vector<boost::int32_t> v;
+
+    for (boost::int32_t i = 0; i < 10; ++i)
+    {
+        v.push_back(i);
+    }
+
+    std::size_t ref_output = boost::hash_range(v.begin(), v.end());
+
+    boost::iterator_range<std::vector<boost::int32_t>::iterator> rng(v);
+
+    std::size_t test_output = boost::hash_value(rng);
+
+    BOOST_CHECK_EQUAL(ref_output, test_output);
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range iterator_range hash function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_iterator_range_hash));
+
+    return test;
+}

test/mutable_iterator.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_mutable_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_mutable_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_mutable_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_mutable_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_mutable_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_mutable_iterator));
+
+    return test;
+}

test/pointer.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/pointer.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_pointer()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::pointer,
+            boost::range_pointer<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_pointer,
+            boost::range_pointer<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::pointer,
+            boost::range_pointer<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_pointer meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_pointer));
+
+    return test;
+}

test/reference.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/reference.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_reference()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::reference,
+            boost::range_reference<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_reference,
+            boost::range_reference<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::reference,
+            boost::range_reference<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_reference meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_reference));
+
+    return test;
+}

test/result_iterator.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/result_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_result_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_result_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::const_iterator,
+            boost::range_result_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::iterator,
+            boost::range_result_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_result_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_result_iterator));
+
+    return test;
+}

test/reverse_iterator.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/reverse_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_reverse_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::iterator>,
+            boost::range_reverse_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::const_iterator>,
+            boost::range_reverse_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::iterator>,
+            boost::range_reverse_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_reverse_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_reverse_iterator));
+
+    return test;
+}

test/reverse_result_iterator.cpp

@@ -0,0 +1,62 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/reverse_result_iterator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_reverse_result_iterator()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::iterator>,
+            boost::range_reverse_result_iterator<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::const_iterator>,
+            boost::range_reverse_result_iterator<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            boost::reverse_iterator<cont::iterator>,
+            boost::range_reverse_result_iterator<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE(
+                "Boost.Range range_reverse_result_iterator meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_reverse_result_iterator));
+
+    return test;
+}

test/size_type.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/size_type.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_size()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::size_type,
+            boost::range_size<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::size_type,
+            boost::range_size<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::size_type,
+            boost::range_size<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_size meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_size));
+
+    return test;
+}

test/value_type.cpp

@@ -0,0 +1,61 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. 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/
+//
+
+#include <boost/range/value_type.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+
+namespace boost_range_test
+{
+    namespace
+    {
+
+void test_value_type()
+{
+    typedef std::vector<int> cont;
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::value_type,
+            boost::range_value<cont>::type
+        >::value));
+
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::value_type,
+            boost::range_value<const cont>::type
+        >::value));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_STATIC_ASSERT((
+        boost::is_same<
+            cont::value_type,
+            boost::range_value<cont&&>::type
+        >::value));
+#endif
+}
+
+    } // anonymous namespace
+} // namespace boost_range_test
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test =
+        BOOST_TEST_SUITE("Boost.Range range_value meta-function");
+
+    test->add(BOOST_TEST_CASE(&boost_range_test::test_value_type));
+
+    return test;
+}