Qualify call to boost::size to avoid ambiguity with std::size

Don't assume that because type `T` is a range that `const T` is also a range.

doc/headers.qbk

@@ -46,7 +46,7 @@
     [[`<boost/range/adaptor/copied.hpp>`]            [__range_adaptors_copied__]]
     [[`<boost/range/adaptor/filtered.hpp>`]          [__range_adaptors_filtered__]]
     [[`<boost/range/adaptor/indexed.hpp>`]           [__range_adaptors_indexed__]]
-    [[`<boost/range/adaptor/indirected.hpp>`]        [__range_adaptors_indirected__]]
+    [[`<boost/range/adaptor/indirected.hpp.`]        [__range_adaptors_indirected__]]
     [[`<boost/range/adaptor/map.hpp>`]               [__range_adaptors_map_keys__ __range_adaptors_map_values__]]
     [[`<boost/range/adaptor/replaced.hpp>`]          [__range_adaptors_replaced__]]
     [[`<boost/range/adaptor/replaced_if.hpp>`]       [__range_adaptors_replaced_if__]]

doc/reference/adaptors.qbk

@@ -172,7 +172,6 @@ rng | boost::adaptors::adaptor_generator
 [include adaptors/indirected.qbk]
 [include adaptors/map_keys.qbk]
 [include adaptors/map_values.qbk]
-[include adaptors/ref_unwrapped.qbk]
 [include adaptors/replaced.qbk]
 [include adaptors/replaced_if.qbk]
 [include adaptors/reversed.qbk]

doc/reference/adaptors/ref_unwrapped.qbk

@@ -1,32 +0,0 @@
-[/
-    Copyright 2015 Robin Eckert
-    Distributed under 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)
-/]
-[section:ref_unwrapped ref_unwrapped]
-
-[table
-    [[Syntax] [Code]]
-    [[Pipe] [`rng | boost::adaptors::ref_unwrapped`]]
-    [[Function] [`boost::adaptors::ref_unwrap(rng)`]]
-]
-
-This adaptor produces a range than applies `.get()` on all values in
-the range. It is useful for iterating ranges of
-`std::reference_wrapper` values or values using similar semantics.
-
-The adaptor is C++11 (and above) only.
-
-* [*Precondition:] The `value_type` of the range has a `.get() const`.
-* [*Postcondition:] For all elements `x` in the returned range, `x` is the result of `y.get()` where `y` is the corresponding element in the original range.
-* [*Range Category:] __single_pass_range__
-* [*Range Return Type:] `boost::unwrap_ref_range<decltype(rng)>`
-* [*Returned Range Category:] The range category of `rng`.
-
-[section:ref_unwrapped_example ref_unwrapped example]
-[import ../../../test/adaptor_test/ref_unwrapped_example.cpp]
-[ref_unwrapped_example]
-[endsect]
-
-This would produce the output `123`.
-[endsect]

doc/reference/adaptors/replaced.qbk

@@ -7,8 +7,8 @@
 
 [table
     [[Syntax] [Code]]
-    [[Pipe] [`rng | boost::adaptors::replaced(old_value, new_value)`]]
-    [[Function] [`boost::adaptors::replace(rng, old_value, new_value)`]]
+    [[Pipe] [`rng | boost::adaptors::replaced(new_value, old_value)`]]
+    [[Function] [`boost::adaptors::replace(rng, new_value, old_value)`]]
 ]
 
 * [*Precondition:]

include/boost/range/adaptor/ref_unwrapped.hpp

@@ -1,102 +0,0 @@
-// Boost.Range library
-//
-//  Copyright Robin Eckert 2015.
-//  Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. 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_ADAPTOR_REF_UNWRAPPED_HPP
-#define BOOST_RANGE_ADAPTOR_REF_UNWRAPPED_HPP
-
-#include <boost/range/adaptor/transformed.hpp>
-#include <boost/range/reference.hpp>
-#include <boost/range/concepts.hpp>
-
-#include <utility>
-
-#if !defined(BOOST_NO_CXX11_DECLTYPE)
-
-namespace boost
-{
-    namespace range_detail
-    {
-        struct ref_unwrapped_forwarder {};
-
-        template<class SinglePassRange>
-        struct unwrap_ref
-        {
-            typedef BOOST_DEDUCED_TYPENAME
-                          range_reference<SinglePassRange>::type argument_type;
-
-            using result_type = decltype(std::declval<argument_type>().get() );
-
-            result_type operator()( argument_type &&r ) const
-            {
-                return r.get();
-            }
-        };
-
-
-        template<class SinglePassRange>
-        class unwrap_ref_range
-            : public transformed_range<unwrap_ref<SinglePassRange>,
-                                       SinglePassRange>
-        {
-            using base = transformed_range<unwrap_ref<SinglePassRange>,
-                                           SinglePassRange>;
-        public:
-            using transform_fn_type = unwrap_ref<SinglePassRange>;
-            using source_range_type = SinglePassRange;
-
-            unwrap_ref_range(transform_fn_type fn, source_range_type &rng)
-                : base(fn, rng)
-            {
-            }
-
-            unwrap_ref_range(const base &other) : base(other) {}
-        };
-
-        template<class SinglePassRange>
-        inline unwrap_ref_range<SinglePassRange>
-        operator|(SinglePassRange& r, ref_unwrapped_forwarder)
-        {
-            BOOST_RANGE_CONCEPT_ASSERT((
-                SinglePassRangeConcept<SinglePassRange>));
-
-            return operator|( r,
-                boost::adaptors::transformed(unwrap_ref<SinglePassRange>()));
-        }
-
-    }
-
-    using range_detail::unwrap_ref_range;
-
-    namespace adaptors
-    {
-        namespace
-        {
-            const range_detail::ref_unwrapped_forwarder ref_unwrapped =
-                                       range_detail::ref_unwrapped_forwarder();
-        }
-
-        template<class SinglePassRange>
-        inline unwrap_ref_range<SinglePassRange>
-        ref_unwrap(SinglePassRange& rng)
-        {
-            BOOST_RANGE_CONCEPT_ASSERT((
-                SinglePassRangeConcept<SinglePassRange>));
-
-            return unwrap_ref_range<SinglePassRange>(
-                range_detail::unwrap_ref<SinglePassRange>(), rng );
-        }
-    } // 'adaptors'
-
-}
-
-#endif
-
-#endif

include/boost/range/algorithm/max_element.hpp

@@ -9,12 +9,12 @@
 #ifndef BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
 #define BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED
 
-#include <boost/algorithm/minmax_element.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
 #include <boost/range/detail/range_return.hpp>
+#include <algorithm>
 
 namespace boost
 {
@@ -32,7 +32,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 max_element(ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return boost::first_max_element(boost::begin(rng), boost::end(rng));
+    return std::max_element(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -41,7 +41,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 max_element(const ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return boost::first_max_element(boost::begin(rng), boost::end(rng));
+    return std::max_element(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -50,7 +50,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 max_element(ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return boost::first_max_element(boost::begin(rng), boost::end(rng), pred);
+    return std::max_element(boost::begin(rng), boost::end(rng), pred);
 }
 
 /// \overload
@@ -59,7 +59,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 max_element(const ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return boost::first_max_element(boost::begin(rng), boost::end(rng), pred);
+    return std::max_element(boost::begin(rng), boost::end(rng), pred);
 }
 
 // range_return overloads
@@ -71,7 +71,7 @@ max_element(ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
-        boost::first_max_element(boost::begin(rng), boost::end(rng)),
+        std::max_element(boost::begin(rng), boost::end(rng)),
         rng);
 }
 
@@ -82,7 +82,7 @@ max_element(const ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
-        boost::first_max_element(boost::begin(rng), boost::end(rng)),
+        std::max_element(boost::begin(rng), boost::end(rng)),
         rng);
 }
 
@@ -93,7 +93,7 @@ max_element(ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
-        boost::first_max_element(boost::begin(rng), boost::end(rng), pred),
+        std::max_element(boost::begin(rng), boost::end(rng), pred),
         rng);
 }
 
@@ -104,7 +104,7 @@ max_element(const ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
-        boost::first_max_element(boost::begin(rng), boost::end(rng), pred),
+        std::max_element(boost::begin(rng), boost::end(rng), pred),
         rng);
 }
 

include/boost/range/algorithm/min_element.hpp

@@ -9,12 +9,12 @@
 #ifndef BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
 #define BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED
 
-#include <boost/algorithm/minmax_element.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
 #include <boost/range/detail/range_return.hpp>
+#include <algorithm>
 
 namespace boost
 {
@@ -32,7 +32,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 min_element(ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return boost::first_min_element(boost::begin(rng), boost::end(rng));
+    return std::min_element(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -41,7 +41,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 min_element(const ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return boost::first_min_element(boost::begin(rng), boost::end(rng));
+    return std::min_element(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -50,7 +50,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
 min_element(ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
-    return boost::first_min_element(boost::begin(rng), boost::end(rng), pred);
+    return std::min_element(boost::begin(rng), boost::end(rng), pred);
 }
 
 /// \overload
@@ -59,7 +59,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 min_element(const ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
-    return boost::first_min_element(boost::begin(rng), boost::end(rng), pred);
+    return std::min_element(boost::begin(rng), boost::end(rng), pred);
 }
 
 // range_return overloads
@@ -71,7 +71,7 @@ min_element(ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
-        boost::first_min_element(boost::begin(rng), boost::end(rng)),
+        std::min_element(boost::begin(rng), boost::end(rng)),
         rng);
 }
 
@@ -82,7 +82,7 @@ min_element(const ForwardRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
-        boost::first_min_element(boost::begin(rng), boost::end(rng)),
+        std::min_element(boost::begin(rng), boost::end(rng)),
         rng);
 }
 
@@ -93,7 +93,7 @@ min_element(ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return range_return<ForwardRange,re>::pack(
-        boost::first_min_element(boost::begin(rng), boost::end(rng), pred),
+        std::min_element(boost::begin(rng), boost::end(rng), pred),
         rng);
 }
 
@@ -104,7 +104,7 @@ min_element(const ForwardRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return range_return<const ForwardRange,re>::pack(
-        boost::first_min_element(boost::begin(rng), boost::end(rng), pred),
+        std::min_element(boost::begin(rng), boost::end(rng), pred),
         rng);
 }
 

include/boost/range/algorithm_ext/insert.hpp

@@ -39,7 +39,6 @@ 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));
-    return on;
 }
 
     } // namespace range

include/boost/range/as_literal.hpp

@@ -25,11 +25,6 @@
 #include <boost/detail/workaround.hpp>
 
 #include <cstring>
-
-#if !defined(BOOST_NO_CXX11_CHAR16_T) || !defined(BOOST_NO_CXX11_CHAR32_T)
-#include <string>  // for std::char_traits
-#endif
-
 #ifndef BOOST_NO_CWCHAR
 #include <cwchar>
 #endif
@@ -43,20 +38,6 @@ namespace boost
             return strlen( s );
         }
 
-#ifndef BOOST_NO_CXX11_CHAR16_T
-        inline std::size_t length( const char16_t* s )
-        {
-            return std::char_traits<char16_t>::length( s );
-        }
-#endif
-
-#ifndef BOOST_NO_CXX11_CHAR32_T
-        inline std::size_t length( const char32_t* s )
-        {
-            return std::char_traits<char32_t>::length( s );
-        }
-#endif
-
 #ifndef BOOST_NO_CWCHAR
         inline std::size_t length( const wchar_t* s )
         {
@@ -80,30 +61,6 @@ namespace boost
             return true;
         }
 
-#ifndef BOOST_NO_CXX11_CHAR16_T
-        inline bool is_char_ptr( char16_t* )
-        {
-            return true;
-        }
-
-        inline bool is_char_ptr( const char16_t* )
-        {
-            return true;
-        }
-#endif
-
-#ifndef BOOST_NO_CXX11_CHAR32_T
-        inline bool is_char_ptr( char32_t* )
-        {
-            return true;
-        }
-
-        inline bool is_char_ptr( const char32_t* )
-        {
-            return true;
-        }
-#endif
-
 #ifndef BOOST_NO_CWCHAR
         inline bool is_char_ptr( wchar_t* )
         {

include/boost/range/concepts.hpp

@@ -25,8 +25,6 @@
 #include <boost/range/detail/misc_concept.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
-#include <iterator>
-
 /*!
  * \file
  * \brief Concept checks for the Boost Range library.
@@ -166,10 +164,10 @@ namespace boost {
                 // work
                 (void)(i++);
 
-                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r1(*i);
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r1(*i);
                 boost::ignore_unused_variable_warning(r1);
 
-                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r2(*(++i));
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
                 boost::ignore_unused_variable_warning(r2);
             }
         private:
@@ -183,7 +181,7 @@ namespace boost {
             , DefaultConstructible<Iterator>
         {
 #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::difference_type difference_type;
+            typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
 
             BOOST_MPL_ASSERT((is_integral<difference_type>));
             BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
@@ -202,7 +200,7 @@ namespace boost {
                 // is convertible to reference.
                 Iterator i2(i++);
                 boost::ignore_unused_variable_warning(i2);
-                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r(*(i++));
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r(*(i++));
                 boost::ignore_unused_variable_warning(r);
             }
         private:

include/boost/range/const_iterator.hpp

@@ -36,7 +36,7 @@ namespace boost
 BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( const_iterator )
 
 template< typename C >
-struct range_const_iterator
+struct range_const_iterator_helper
         : extract_const_iterator<C>
 {};
 
@@ -45,7 +45,7 @@ struct range_const_iterator
 //////////////////////////////////////////////////////////////////////////
 
 template< typename Iterator >
-struct range_const_iterator<std::pair<Iterator,Iterator> >
+struct range_const_iterator_helper<std::pair<Iterator,Iterator> >
 {
     typedef Iterator type;
 };
@@ -55,7 +55,7 @@ struct range_const_iterator<std::pair<Iterator,Iterator> >
 //////////////////////////////////////////////////////////////////////////
 
 template< typename T, std::size_t sz >
-struct range_const_iterator< T[sz] >
+struct range_const_iterator_helper< T[sz] >
 {
     typedef const T* type;
 };
@@ -64,7 +64,7 @@ struct range_const_iterator< T[sz] >
 
 template<typename C, typename Enabler=void>
 struct range_const_iterator
-        : range_detail::range_const_iterator<
+        : range_detail::range_const_iterator_helper<
             BOOST_DEDUCED_TYPENAME remove_reference<C>::type
         >
 {

include/boost/range/detail/any_iterator.hpp

@@ -247,9 +247,8 @@ namespace boost
             any_iterator_type stored_iterator;
         };
 
-
-    }
-    }
+    } //namespace detail
+    } //namespace iterators
 
     namespace range_detail
     {

include/boost/range/detail/common.hpp

@@ -18,8 +18,10 @@
 #include <boost/range/config.hpp>
 #include <boost/range/detail/sfinae.hpp>
 #include <boost/type_traits/is_void.hpp>
+#include <boost/mpl/bool.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/or.hpp>
 #include <cstddef>
 
 //////////////////////////////////////////////////////////////////////////////
@@ -69,7 +71,7 @@ namespace boost
             BOOST_STATIC_CONSTANT( bool, is_const_wchar_t_ptr_   = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type ) );
             BOOST_STATIC_CONSTANT( bool, is_char_array_          = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type ) );
             BOOST_STATIC_CONSTANT( bool, is_wchar_t_array_       = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type ) );
-            BOOST_STATIC_CONSTANT( bool, is_string_              = (is_const_char_ptr_ || is_const_wchar_t_ptr_));
+            BOOST_STATIC_CONSTANT( bool, is_string_              = (boost::mpl::or_<boost::mpl::bool_<is_const_char_ptr_>, boost::mpl::bool_<is_const_wchar_t_ptr_> >::value ));
             BOOST_STATIC_CONSTANT( bool, is_array_               = boost::is_array<C>::value );
             
         };

include/boost/range/detail/join_iterator.hpp

@@ -153,12 +153,8 @@ template<typename Iterator1
                                     typename iterator_reference<Iterator2>::type
                                 >::type
                             >::value,
-                            typename add_reference<
-                                typename add_const<
-                                    typename remove_reference<
-                                        typename iterator_reference<Iterator1>::type
-                                    >::type
-                                >::type
+                            typename add_const<
+                                typename iterator_reference<Iterator1>::type
                             >::type,
                             typename iterator_reference<Iterator1>::type
                         >::type

include/boost/range/has_range_iterator.hpp

@@ -37,9 +37,9 @@ namespace boost
             T,
             BOOST_DEDUCED_TYPENAME ::boost::enable_if<
                 BOOST_DEDUCED_TYPENAME mpl::eval_if<is_const<T>,
-                    has_type<boost::range_const_iterator<
+                    has_type<range_const_iterator<
                                 BOOST_DEDUCED_TYPENAME remove_const<T>::type> >,
-                    has_type<boost::range_mutable_iterator<T> >
+                    has_type<range_mutable_iterator<T> >
                 >::type
             >::type
         >
@@ -57,7 +57,7 @@ namespace boost
         struct has_range_const_iterator_impl<
             T,
             BOOST_DEDUCED_TYPENAME ::boost::enable_if<
-                has_type<boost::range_const_iterator<T> >
+                has_type<range_const_iterator<T> >
             >::type
         >
             : boost::mpl::true_

test/Jamfile.v2

@@ -59,8 +59,6 @@ test-suite range :
     [ range-test adaptor_test/indexed ]
     [ range-test adaptor_test/indirected ]
     [ range-test adaptor_test/map ]
-    [ range-test adaptor_test/ref_unwrapped ]
-    [ range-test adaptor_test/ref_unwrapped_example ]
     [ range-test adaptor_test/replaced ]
     [ range-test adaptor_test/replaced_if ]
     [ range-test adaptor_test/reversed ]

test/adaptor_test/ref_unwrapped.cpp

@@ -1,101 +0,0 @@
-// Boost.Range library
-//
-//  Copyright Robin Eckert 2015. 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/adaptor/ref_unwrapped.hpp>
-
-#define BOOST_TEST_MAIN
-
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test.hpp>
-
-#include <vector>
-
-#if !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) && !defined(BOOST_NO_CXX11_RANGE_BASED_FOR)
-
-namespace boost
-{
-
-    BOOST_AUTO_TEST_CASE(test_mutable)
-    {
-        int one = 1;
-        int two = 2;
-        int three = 3;
-
-        std::vector<std::reference_wrapper<int>> input_values{one, two, three};
-
-        const std::vector<int*> expected{&one, &two, &three};
-        std::vector<int*> actual;
-
-        for (auto&& value : input_values | adaptors::ref_unwrapped)
-        {
-          actual.push_back(&value);
-        }
-
-        BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(),
-                                      expected.end(),
-                                      actual.begin(),
-                                      actual.end());
-    }
-
-    BOOST_AUTO_TEST_CASE(test_const_range)
-    {
-        int one = 1;
-        int two = 2;
-        int three = 3;
-
-        const std::vector<std::reference_wrapper<int>> input_values{one, two, three};
-
-        const std::vector<int*> expected{&one, &two, &three};
-        std::vector<int*> actual;
-
-        for (auto&& value : input_values | adaptors::ref_unwrapped)
-        {
-          actual.push_back(&value);
-        }
-
-        BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(),
-                                      expected.end(),
-                                      actual.begin(),
-                                      actual.end());
-    }
-
-    BOOST_AUTO_TEST_CASE(test_const_reference)
-    {
-        const int one = 1;
-        const int two = 2;
-        const int three = 3;
-
-        const std::vector<std::reference_wrapper<const int>> input_values{one, two, three};
-
-        const std::vector<const int*> expected{&one, &two, &three};
-        std::vector<const int*> actual;
-
-        for (auto&& value : input_values | adaptors::ref_unwrapped)
-        {
-          actual.push_back(&value);
-        }
-
-        BOOST_CHECK_EQUAL_COLLECTIONS(expected.begin(),
-                                      expected.end(),
-                                      actual.begin(),
-                                      actual.end());
-    }
-
-
-}
-
-#else
-
-BOOST_AUTO_TEST_CASE(empty)
-{
-  // C++11 only
-}
-
-#endif

test/adaptor_test/ref_unwrapped_example.cpp

@@ -1,47 +0,0 @@
-// Boost.Range library
-//
-//  Copyright Robin Eckert 2015. 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/
-//
-//[ref_unwrapped_example
-#include <boost/range/adaptor/ref_unwrapped.hpp>
-#include <iostream>
-#include <vector>
-
-struct example
-{
-  int value;
-};
-
-int main(int argc, const char* argv[])
-{
-//<-
-#if !defined(BOOST_NO_CXX11_DECLTYPE) \
- && !defined(BOOST_NO_CXX11_RANGE_BASED_FOR) \
- && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) \
- && !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS)
-//->
-    using boost::adaptors::ref_unwrapped;
-
-    example one{1};
-    example two{2};
-    example three{3};
-
-    std::vector<std::reference_wrapper<example> > input{one, two, three};
-
-    for (auto&& entry : input | ref_unwrapped)
-    {
-      std::cout << entry.value;
-    }
-
-    return 0;
-//<-
-#endif
-//->
-}
-//]

test/adaptor_test/strided.cpp

@@ -9,7 +9,7 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 // The strided_defect_Trac5014 test case is a modified version of a test case
-// contributed by Maxim Yanchenko as part of the trac ticket.
+// contributed by Michel Morin as part of the trac ticket.
 //
 // The deque test case has been removed due to erroneous standard library
 // implementations causing test failures.

test/iterator_pair.cpp

@@ -22,8 +22,6 @@
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
 #include <vector>
-#include <iterator>
-#include <utility>
 
 void check_iterator_pair()
 {
@@ -41,23 +39,23 @@ void check_iterator_pair()
 
 
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<pair_t>::type,
-                          std::iterator_traits<pair_t::first_type>::value_type>::value ));
+                          boost::detail::iterator_traits<pair_t::first_type>::value_type>::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_const_iterator<pair_t>::type, pair_t::first_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<pair_t>::type,
-                          std::iterator_traits<pair_t::first_type>::difference_type >::value ));
+                          boost::detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<pair_t>::type, std::size_t >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<pair_t>::type, pair_t::first_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
 
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<const_pair_tt>::type,
-                          std::iterator_traits<const_pair_t::first_type>::value_type>::value ));
+                          boost::detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
     //
     // This behavior is not supported with v2.
     //BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_difference<const_pair_tt>::type,
-                          std::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
+                          boost::detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_size<const_pair_tt>::type, std::size_t >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));

test/iterator_range.cpp

@@ -59,8 +59,8 @@ void check_iterator_range()
         BOOST_CHECK( false );
 //#endif
 
-    BOOST_CHECK_EQUAL( r.size(), size( r ) );
-    BOOST_CHECK_EQUAL( r2.size(), size( r2 ) );
+    BOOST_CHECK_EQUAL( r.size(), boost::size( r ) );
+    BOOST_CHECK_EQUAL( r2.size(), boost::size( r2 ) );
 
     BOOST_CHECK_EQUAL( std::distance( r.begin(), r.end() ),
                        std::distance( boost::begin( r2 ), boost::end( r2 ) ) );
@@ -280,23 +280,6 @@ void test_sfinae()
     boost::iterator_range<ptr_iterator> r(ptr_iterator(0), ptr_iterator(0));
 }
 
-boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
-{
-    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
-
-    test->add(BOOST_TEST_CASE(&check_iterator_range));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less>));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less_or_equal>));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater>));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater_or_equal>));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::equal_to>));
-    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::not_equal_to>));
-    test->add(BOOST_TEST_CASE(&iterator_range_test_detail::check_make_iterator_range_n));
-    test->add(BOOST_TEST_CASE(&test_advance));
-
-    return test;
-}
-
 //
 //
 // Check that constness is propagated correct from
@@ -327,3 +310,21 @@ void check_reference_type()
     test_iter_range<veci_type>(a_vec);
     test_iter_range<veci_type const>(a_vec);
 }
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+{
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    
+    test->add(BOOST_TEST_CASE(&check_iterator_range));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less>));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::less_or_equal>));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater>));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::greater_or_equal>));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::equal_to>));
+    test->add(BOOST_TEST_CASE(&check_iterator_range_operator<iterator_range_test_detail::not_equal_to>));
+    test->add(BOOST_TEST_CASE(&iterator_range_test_detail::check_make_iterator_range_n));
+    test->add(BOOST_TEST_CASE(&test_advance));
+    
+    return test;
+}
+

test/join.cpp

@@ -277,7 +277,6 @@ namespace boost
             std::vector<int> v2;
             std::vector<int> joined;
             boost::push_back(joined, join(v1, v2));
-            boost::push_back(joined, join(v2, v1));
         }
 
         namespace trac7376