Split Travis jobs to avoid timeout

boost::detail::iterator_traits was used without including the necessary header
file. It's deprecated anyway and only maps to std::iterator_traits. Also,
utility was missing for std::pair.

.travis.yml

@@ -0,0 +1,131 @@
+# Copyright 2016, 2017 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc-5 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc-5 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc-6 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc-6 CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-7
+      env: TOOLSET=gcc-7 CXXSTD=14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=14,1z
+      addons:
+        apt:
+          packages:
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=03,11
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang CXXSTD=14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - cp -r $TRAVIS_BUILD_DIR/* libs/range
+  - python tools/boostdep/depinst/depinst.py range
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - ./b2 -j 3 libs/range/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

doc/Jamfile.v2

@@ -28,3 +28,8 @@ boostbook quickbook
     <format>pdf:<xsl:param>img.src.path=$(images_location)/
   ;
 
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : quickbook ;
+explicit boostrelease ;

doc/reference/adaptors/filtered.qbk

@@ -12,9 +12,9 @@
 ]
 
 * [*Precondition:]  The `value_type` of the range is convertible to the argument type of `pred`.
-* [*Postcondition:] For all adjacent elements `[x]` in the returned range, `pred(x)` is `true`.
+* [*Postcondition:] For all elements `[x]` in the returned range, `pred(x)` is `true`.
 * [*Throws:] Whatever the copy constructor of `pred` might throw.
-* [*Range Category:] __forward_range__
+* [*Range Category:] __singlepass_range__
 * [*Range Return Type:] `boost::filtered_range<decltype(rng)>`
 * [*Returned Range Category:] The minimum of the range category of `rng` and __bidirectional_range__
 

include/boost/range/adaptor/filtered.hpp

@@ -56,23 +56,23 @@ namespace boost
             { }
         };
 
-        template< class ForwardRange, class Predicate >
-        inline filtered_range<Predicate, ForwardRange>
-        operator|(ForwardRange& r,
+        template< class SinglePassRange, class Predicate >
+        inline filtered_range<Predicate, SinglePassRange>
+        operator|(SinglePassRange& r,
                   const filter_holder<Predicate>& f)
         {
-            BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-            return filtered_range<Predicate, ForwardRange>( f.val, r );
+            BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+            return filtered_range<Predicate, SinglePassRange>( f.val, r );
         }
 
-        template< class ForwardRange, class Predicate >
-        inline filtered_range<Predicate, const ForwardRange>
-        operator|(const ForwardRange& r,
+        template< class SinglePassRange, class Predicate >
+        inline filtered_range<Predicate, const SinglePassRange>
+        operator|(const SinglePassRange& r,
                   const filter_holder<Predicate>& f )
         {
             BOOST_RANGE_CONCEPT_ASSERT((
-                ForwardRangeConcept<const ForwardRange>));
-            return filtered_range<Predicate, const ForwardRange>( f.val, r );
+                SinglePassRangeConcept<const SinglePassRange>));
+            return filtered_range<Predicate, const SinglePassRange>( f.val, r );
         }
 
     } // 'range_detail'
@@ -93,23 +93,26 @@ namespace boost
                        range_detail::forwarder<range_detail::filter_holder>();
         }
 
-        template<class ForwardRange, class Predicate>
-        inline filtered_range<Predicate, ForwardRange>
-        filter(ForwardRange& rng, Predicate filter_pred)
-        {
-            BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
-
-            return range_detail::filtered_range<Predicate, ForwardRange>( filter_pred, rng );
-        }
-
-        template<class ForwardRange, class Predicate>
-        inline filtered_range<Predicate, const ForwardRange>
-        filter(const ForwardRange& rng, Predicate filter_pred)
+        template<class SinglePassRange, class Predicate>
+        inline filtered_range<Predicate, SinglePassRange>
+        filter(SinglePassRange& rng, Predicate filter_pred)
         {
             BOOST_RANGE_CONCEPT_ASSERT((
-                ForwardRangeConcept<const ForwardRange>));
+                SinglePassRangeConcept<SinglePassRange>));
 
-            return range_detail::filtered_range<Predicate, const ForwardRange>( filter_pred, rng );
+            return range_detail::filtered_range<
+                Predicate, SinglePassRange>( filter_pred, rng );
+        }
+
+        template<class SinglePassRange, class Predicate>
+        inline filtered_range<Predicate, const SinglePassRange>
+        filter(const SinglePassRange& rng, Predicate filter_pred)
+        {
+            BOOST_RANGE_CONCEPT_ASSERT((
+                SinglePassRangeConcept<const SinglePassRange>));
+
+            return range_detail::filtered_range<
+                Predicate, const SinglePassRange>( filter_pred, rng );
         }
     } // 'adaptors'
 

include/boost/range/adaptor/strided.hpp

@@ -603,7 +603,7 @@ namespace boost
         template<
             class Rng,
             class Category =
-                typename iterator_traversal<
+                typename iterators::pure_iterator_traversal<
                     typename range_iterator<Rng>::type
                 >::type
         >

include/boost/range/concepts.hpp

@@ -25,6 +25,8 @@
 #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.
@@ -164,10 +166,10 @@ namespace boost {
                 // work
                 (void)(i++);
 
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r1(*i);
+                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r1(*i);
                 boost::ignore_unused_variable_warning(r1);
 
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
+                BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::reference r2(*(++i));
                 boost::ignore_unused_variable_warning(r2);
             }
         private:
@@ -181,7 +183,7 @@ namespace boost {
             , DefaultConstructible<Iterator>
         {
 #if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
+            typedef BOOST_DEDUCED_TYPENAME std::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);
@@ -200,7 +202,7 @@ namespace boost {
                 // is convertible to reference.
                 Iterator i2(i++);
                 boost::ignore_unused_variable_warning(i2);
-                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r(*(i++));
+                BOOST_DEDUCED_TYPENAME std::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/common.hpp

@@ -18,9 +18,10 @@
 #include <boost/range/config.hpp>
 #include <boost/range/detail/sfinae.hpp>
 #include <boost/type_traits/is_void.hpp>
-#include <boost/type_traits/detail/ice_or.hpp>
+#include <boost/mpl/bool.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/int.hpp>
+#include <boost/mpl/or.hpp>
 #include <cstddef>
 
 //////////////////////////////////////////////////////////////////////////////
@@ -70,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_              = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value ));
+            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/difference_type.hpp

@@ -15,20 +15,32 @@
 # pragma once
 #endif
 
+#include <boost/mpl/and.hpp>
 #include <boost/range/config.hpp>
 #include <boost/range/iterator.hpp>
+#include <boost/range/has_range_iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 
 namespace boost
 {
+    namespace range_detail
+    {
+        template< class T, bool B = has_type<range_iterator<T> >::value >
+        struct range_difference
+        { };
+
+        template< class T >
+        struct range_difference<T, true>
+          : iterator_difference<
+                BOOST_DEDUCED_TYPENAME range_iterator<T>::type
+            >
+        { };
+    }
+
     template< class T >
     struct range_difference
-            : iterator_difference<
-                BOOST_DEDUCED_TYPENAME range_iterator<
-                    BOOST_DEDUCED_TYPENAME remove_reference<T>::type
-                >::type
-            >
+      : range_detail::range_difference<BOOST_DEDUCED_TYPENAME remove_reference<T>::type>
     { };
 }
 

include/boost/range/iterator.hpp

@@ -46,31 +46,29 @@ namespace boost
        };       
     }  
     
-#endif  
-
     template< typename C, typename Enabler=void >
     struct range_iterator
     {
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-  
+
         typedef BOOST_RANGE_DEDUCED_TYPENAME  
                range_detail_vc7_1::range_iterator<C>::type type;  
-           
-#else  
 
-    private:
-        typedef typename remove_reference<C>::type param_t;
-
-    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         
     };
-    
+
+#else
+
+    template< typename C, typename Enabler=void >
+    struct range_iterator
+      : mpl::if_c<
+            is_const<typename remove_reference<C>::type>::value,
+            range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
+            range_mutable_iterator<typename remove_reference<C>::type>
+        >::type
+    {
+    };
+
+#endif
+
 } // namespace boost
 
 #endif

include/boost/range/iterator_range_core.hpp

@@ -66,13 +66,13 @@ namespace boost
             template< class ForwardRange >
             static IteratorT adl_begin( ForwardRange& r )
             {
-                return static_cast<IteratorT>( boost::begin( r ) );
+                return IteratorT( boost::begin( r ) );
             }
 
             template< class ForwardRange >
             static IteratorT adl_end( ForwardRange& r )
             {
-                return static_cast<IteratorT>( boost::end( r ) );
+                return IteratorT( boost::end( r ) );
             }
         };
 

include/boost/range/size.hpp

@@ -54,11 +54,20 @@ namespace boost
     inline typename range_size<const SinglePassRange>::type
     size(const SinglePassRange& rng)
     {
+// Very strange things happen on some compilers that have the range concept
+// asserts disabled. This preprocessor condition is clearly redundant on a
+// working compiler but is vital for at least some compilers such as clang 4.2
+// but only on the Mac!
+#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
+        BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<SinglePassRange>));
+#endif
+
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
         using namespace range_detail;
 #endif
+
         return range_calculate_size(rng);
     }
 

include/boost/range/size_type.hpp

@@ -18,6 +18,7 @@
 #include <boost/range/config.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/range/concepts.hpp>
+#include <boost/range/has_range_iterator.hpp>
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
@@ -51,7 +52,7 @@ namespace boost
         };
 
         template<typename C, typename Enabler=void>
-        struct range_size
+        struct range_size_
         {
             typedef BOOST_DEDUCED_TYPENAME make_unsigned<
                 BOOST_DEDUCED_TYPENAME range_difference<C>::type
@@ -59,7 +60,7 @@ namespace boost
         };
 
         template<typename C>
-        struct range_size<
+        struct range_size_<
             C,
             BOOST_DEDUCED_TYPENAME ::boost::enable_if<has_size_type<C>, void>::type
         >
@@ -67,29 +68,20 @@ namespace boost
             typedef BOOST_DEDUCED_TYPENAME C::size_type type;
         };
 
+        template<typename C, bool B = range_detail::has_type< range_iterator<C> >::value>
+        struct range_size
+        { };
+
+        template<typename C>
+        struct range_size<C, true>
+          : range_size_<C>
+        { };
     }
 
     template< class T >
     struct range_size :
         detail::range_size<T>
-    {
-// Very strange things happen on some compilers that have the range concept
-// asserts disabled. This preprocessor condition is clearly redundant on a
-// working compiler but is vital for at least some compilers such as clang 4.2
-// but only on the Mac!
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1
-        BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
-#endif
-    };
-
-    template< class T >
-    struct range_size<const T >
-        : detail::range_size<T>
-    {
-#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT == 1        
-        BOOST_RANGE_CONCEPT_ASSERT((boost::SinglePassRangeConcept<T>));
-#endif
-    };
+    { };
 
 } // namespace boost
 

include/boost/range/sub_range.hpp

@@ -182,8 +182,8 @@ public:
 
 #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) 
         sub_range(const sub_range& r)
-            : base(impl::adl_begin(static_cast<const base&>(r)),
-                   impl::adl_end(static_cast<const base&>(r)))
+            : base(impl::adl_begin(const_cast<base&>(static_cast<const base&>(r))),
+                   impl::adl_end(const_cast<base&>(static_cast<const base&>(r))))
         { }  
 #endif
 

test/Jamfile.v2

@@ -40,10 +40,6 @@ test-suite range :
     [ compile-fail compile_fail/adaptor/copied_concept2.cpp ]
     [ compile-fail compile_fail/adaptor/copied_concept3.cpp ]
     [ compile-fail compile_fail/adaptor/copied_concept4.cpp ]
-    [ compile-fail compile_fail/adaptor/filtered_concept.cpp ]
-    [ compile-fail compile_fail/adaptor/filtered_concept2.cpp ]
-    [ compile-fail compile_fail/adaptor/filtered_concept3.cpp ]
-    [ compile-fail compile_fail/adaptor/filtered_concept4.cpp ]
     [ compile-fail compile_fail/adaptor/reversed_concept.cpp ]
     [ compile-fail compile_fail/adaptor/reversed_concept2.cpp ]
     [ compile-fail compile_fail/adaptor/reversed_concept3.cpp ]
@@ -219,6 +215,7 @@ test-suite range :
     [ range-test ticket_5811_indirected_optional ]
     [ range-test ticket_6715_iterator_range_equality ]
     [ range-test ticket_6944 ]
+    [ range-test ticket_10336 ]
     [ range-test value_type ]
     ;
 

test/adaptor_test/filtered.cpp

@@ -21,6 +21,7 @@
 #include <set>
 #include <string>
 #include <vector>
+#include <sstream>
 
 namespace boost
 {
@@ -113,12 +114,35 @@ namespace boost
             filtered_test_impl< Container, is_even >();
         }
 
+        void ticket_10988_single_pass()
+        {
+            std::vector<int> v;
+            std::string str("0 1 2 3 4 5");
+            std::istringstream in(str);
+
+            boost::push_back(v,
+                boost::make_iterator_range(
+                    std::istream_iterator<int>(in),
+                    std::istream_iterator<int>())
+                | boost::adaptors::filtered(is_even()));
+
+            std::vector<int> reference;
+            for (int i = 0; i < 6; i += 2)
+            {
+                reference.push_back(i);
+            }
+            BOOST_CHECK_EQUAL_COLLECTIONS(
+                reference.begin(), reference.end(),
+                v.begin(), v.end());
+        }
+
         void filtered_test()
         {
             filtered_test_all_predicates< std::vector< int > >();
             filtered_test_all_predicates< std::list< int > >();
             filtered_test_all_predicates< std::set< int > >();
             filtered_test_all_predicates< std::multiset< int > >();
+            ticket_10988_single_pass();
         }
     }
 }

test/algorithm.cpp

@@ -457,7 +457,7 @@ void simple_compile_test()
 
     BOOST_RANGE_RETURNS_TEST2( find_end, v, std::less<int>() );
     BOOST_RANGE_RETURNS_TEST2( find_first_of, v, std::less<int>() );
-    BOOST_RANGE_RETURNS_TEST2( search, v, std::less<int>() );
+    BOOST_RANGE_RETURNS_TEST2( boost::search, v, std::less<int>() );
     BOOST_RANGE_RETURNS_TEST2( lower_bound, 0, std::less<int>() );
     BOOST_RANGE_RETURNS_TEST2( upper_bound, 0, std::less<int>() );
 

test/compile_fail/adaptor/filtered_concept.cpp

@@ -1,38 +0,0 @@
-// 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 "mock_range.hpp"
-#include <boost/range/adaptor/filtered.hpp>
-
-namespace
-{
-
-struct always_true
-{
-    typedef bool result_type;
-
-    bool operator()(int) const
-    {
-        return true;
-    }
-};
-
-} // anonymous namespace
-
-int main(int, const char**)
-{
-    using boost::range::unit_test::mock_range;
-    using boost::adaptors::filtered;
-
-    // This next line should fail when Boost.Range concept checking is
-    // enabled since the filtered adaptor takes at least a ForwardRange.
-    return (mock_range<boost::single_pass_traversal_tag>() |
-                filtered(always_true())).front();
-}

test/compile_fail/adaptor/filtered_concept2.cpp

@@ -1,38 +0,0 @@
-// 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 "mock_range.hpp"
-#include <boost/range/adaptor/filtered.hpp>
-
-namespace
-{
-
-struct always_true
-{
-    typedef bool result_type;
-
-    bool operator()(int) const
-    {
-        return true;
-    }
-};
-
-} // anonymous namespace
-
-int main(int, const char**)
-{
-    using boost::range::unit_test::mock_const_range;
-    using boost::adaptors::filtered;
-
-    // This next line should fail when Boost.Range concept checking is
-    // enabled since the filtered adaptor takes at least a ForwardRange.
-    return (mock_const_range<boost::single_pass_traversal_tag>() |
-                filtered(always_true())).front();
-}

test/compile_fail/adaptor/filtered_concept3.cpp

@@ -1,38 +0,0 @@
-// 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 "mock_range.hpp"
-#include <boost/range/adaptor/filtered.hpp>
-
-namespace
-{
-
-struct always_true
-{
-    typedef bool result_type;
-
-    bool operator()(int) const
-    {
-        return true;
-    }
-};
-
-} // anonymous namespace
-
-int main(int, const char**)
-{
-    using boost::range::unit_test::mock_range;
-
-    // This next line should fail when Boost.Range concept checking is
-    // enabled since the filtered adaptor takes at least a ForwardRange.
-    return boost::adaptors::filter(
-        mock_range<boost::single_pass_traversal_tag>(),
-        always_true()).front();
-}

test/compile_fail/adaptor/filtered_concept4.cpp

@@ -1,38 +0,0 @@
-// 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 "mock_range.hpp"
-#include <boost/range/adaptor/filtered.hpp>
-
-namespace
-{
-
-struct always_true
-{
-    typedef bool result_type;
-
-    bool operator()(int) const
-    {
-        return true;
-    }
-};
-
-} // anonymous namespace
-
-int main(int, const char**)
-{
-    using boost::range::unit_test::mock_const_range;
-
-    // This next line should fail when Boost.Range concept checking is
-    // enabled since the filtered adaptor takes at least a ForwardRange.
-    return boost::adaptors::filter(
-        mock_const_range<boost::single_pass_traversal_tag>(),
-        always_true()).front();
-}

test/iterator_pair.cpp

@@ -22,6 +22,8 @@
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
 #include <vector>
+#include <iterator>
+#include <utility>
 
 void check_iterator_pair()
 {
@@ -39,23 +41,23 @@ void check_iterator_pair()
 
 
     BOOST_STATIC_ASSERT(( boost::is_same< boost::range_value<pair_t>::type,
-                          boost::detail::iterator_traits<pair_t::first_type>::value_type>::value ));
+                          std::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,
-                          boost::detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
+                          std::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,
-                          boost::detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
+                          std::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,
-                          boost::detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
+                          std::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 ) ) );

test/sub_range.cpp

@@ -244,6 +244,22 @@ inline void test_advance()
     BOOST_CHECK_EQUAL(r3.advance_end(-1).size(), 1u);
 }
 
+void ticket_10514()
+{
+    typedef std::vector<int> vec_t;
+    typedef boost::sub_range<vec_t> range_t;
+    vec_t v(10);
+    range_t r(v.begin(), v.end());
+    const range_t& cr = r;
+    range_t copy_r = cr;
+
+    BOOST_CHECK(r.begin() == copy_r.begin());
+    BOOST_CHECK(r.end() == copy_r.end());
+
+    BOOST_CHECK(cr.begin() == copy_r.begin());
+    BOOST_CHECK(cr.end() == copy_r.end());
+}
+
     } // anonymous namespace
 } // namespace boost_range_test
 
@@ -262,6 +278,8 @@ boost::unit_test::test_suite* init_unit_test_suite(int, char*[])
 
     test->add(BOOST_TEST_CASE(&boost_range_test::test_advance));
 
+    test->add(BOOST_TEST_CASE(&boost_range_test::ticket_10514));
+
     return test;
 }
 

test/ticket_10336.cpp

@@ -0,0 +1,43 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2011. 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.hpp>
+#include <boost/unordered_map.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+namespace boost
+{
+    namespace
+    {
+        // Ticket 10336 - compilation error in iterator_range and unordered_map
+        void test_ticket_10336()
+        {
+            typedef boost::unordered_map<int,int> container_t;
+            typedef container_t::const_iterator citer_t;
+            typedef boost::iterator_range<citer_t> rng_t;
+            
+            const container_t c;
+            rng_t rng(c.begin(), c.end());
+        }
+    }
+}
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+    boost::unit_test::test_suite* test
+        = BOOST_TEST_SUITE( "RangeTestSuite.ticket_10336" );
+
+    test->add( BOOST_TEST_CASE( &boost::test_ticket_10336 ) );
+
+    return test;
+}