Merge branch 'develop'

fix build break on msvc-8.0

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__
 

doc/reference/algorithms.qbk

@@ -63,7 +63,7 @@ std::vector<int> vec = ...;
 boost::erase(vec, boost::unique<boost::return_found_end>(boost::sort(vec)));
 ``
 
-Notice the use of `boost::return_found_end`. What if we wanted to erase all the duplicates except one of them? In old-fashined STL-programming we might write
+Notice the use of `boost::return_found_end`. What if we wanted to erase all the duplicates except one of them? In old-fashioned STL-programming we might write
 
 ``
 // assume 'vec' is already sorted

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/detail/any_iterator.hpp

@@ -114,6 +114,8 @@ namespace boost
         };
     } // namespace range_detail
 
+    namespace iterators
+    {
     namespace detail
     {
         // Rationale:
@@ -245,8 +247,8 @@ namespace boost
             any_iterator_type stored_iterator;
         };
 
-
-    }
+    } //namespace detail
+    } //namespace iterators
 
     namespace range_detail
     {

include/boost/range/detail/any_iterator_wrapper.hpp

@@ -10,7 +10,7 @@
 #ifndef BOOST_RANGE_DETAIL_ANY_ITERATOR_WRAPPER_HPP_INCLUDED
 #define BOOST_RANGE_DETAIL_ANY_ITERATOR_WRAPPER_HPP_INCLUDED
 
-#include <boost/polymorphic_cast.hpp>
+#include <boost/cast.hpp>
 #include <boost/range/config.hpp>
 #include <boost/range/detail/any_iterator_interface.hpp>
 #include <boost/range/concepts.hpp>

include/boost/range/detail/collection_traits.hpp

@@ -22,7 +22,6 @@
 #ifndef BOOST_RANGE_STRING_COLLECTION_TRAITS_HPP
 #define BOOST_RANGE_STRING_COLLECTION_TRAITS_HPP
 
-#include <boost/algorithm/string/config.hpp>
 #include <boost/type_traits/is_array.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/mpl/eval_if.hpp>
@@ -74,13 +73,13 @@ namespace boost {
         struct collection_traits
         {
         private:
-            typedef BOOST_STRING_TYPENAME ::boost::mpl::eval_if< 
+            typedef typename ::boost::mpl::eval_if<
                     ::boost::algorithm::detail::is_pair<T>, 
                         detail::pair_container_traits_selector<T>,
-                        BOOST_STRING_TYPENAME ::boost::mpl::eval_if< 
+                        typename ::boost::mpl::eval_if<
                         ::boost::is_array<T>, 
                             detail::array_container_traits_selector<T>,
-                            BOOST_STRING_TYPENAME ::boost::mpl::eval_if<
+                            typename ::boost::mpl::eval_if<
                             ::boost::is_pointer<T>,
                                 detail::pointer_container_traits_selector<T>,
                                 detail::default_container_traits_selector<T>
@@ -91,22 +90,22 @@ namespace boost {
             //! Function type       
             typedef container_helper_type function_type;        
             //! Value type
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::value_type value_type;
             //! Size type
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::size_type size_type;
             //! Iterator type
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::iterator iterator;
             //! Const iterator type
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::const_iterator const_iterator;
             //! Result iterator type ( iterator of const_iterator, depending on the constness of the container )
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::result_iterator result_iterator;
             //! Difference type
-            typedef BOOST_STRING_TYPENAME 
+            typedef typename
                 container_helper_type::difference_type difference_type;
 
         }; // 'collection_traits'
@@ -120,7 +119,7 @@ namespace boost {
         template< typename C >
         struct value_type_of
         {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::value_type type;
+            typedef typename collection_traits<C>::value_type type;
         };
         
         //! Container difference trait
@@ -130,7 +129,7 @@ namespace boost {
         template< typename C >
         struct difference_type_of
         {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::difference_type type;
+            typedef typename collection_traits<C>::difference_type type;
         };
 
         //! Container iterator trait
@@ -140,7 +139,7 @@ namespace boost {
         template< typename C >
         struct iterator_of
         {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::iterator type;
+            typedef typename collection_traits<C>::iterator type;
         };
 
         //! Container const_iterator trait
@@ -150,7 +149,7 @@ namespace boost {
         template< typename C >
         struct const_iterator_of
         {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::const_iterator type;
+            typedef typename collection_traits<C>::const_iterator type;
         };
 
 
@@ -162,7 +161,7 @@ namespace boost {
         template< typename C >
         struct result_iterator_of
         {
-            typedef BOOST_STRING_TYPENAME collection_traits<C>::result_iterator type;
+            typedef typename collection_traits<C>::result_iterator type;
         };
 
 //  collection_traits related functions -----------------------------------------//
@@ -172,7 +171,7 @@ namespace boost {
             Get the size of the container. Uses collection_traits.
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::size_type
+        inline typename collection_traits<C>::size_type
         size( const C& c )
         {
             return collection_traits<C>::function_type::size( c ); 
@@ -195,7 +194,7 @@ namespace boost {
             Get the begin iterator of the container. Uses collection_traits.
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
+        inline typename collection_traits<C>::iterator
         begin( C& c )
         {
             return collection_traits<C>::function_type::begin( c ); 
@@ -206,7 +205,7 @@ namespace boost {
             \overload
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
+        inline typename collection_traits<C>::const_iterator
         begin( const C& c )
         {
             return collection_traits<C>::function_type::begin( c ); 
@@ -217,7 +216,7 @@ namespace boost {
             Get the begin iterator of the container. Uses collection_traits.
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::iterator
+        inline typename collection_traits<C>::iterator
         end( C& c )
         {
             return collection_traits<C>::function_type::end( c );
@@ -228,7 +227,7 @@ namespace boost {
             \overload           
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::const_iterator
+        inline typename collection_traits<C>::const_iterator
         end( const C& c )
         {
             return collection_traits<C>::function_type::end( c );
@@ -241,7 +240,7 @@ namespace boost {
             \overload
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
+        inline typename collection_traits<C>::result_iterator
         begin( C& c )
         {
             return collection_traits<C>::function_type::begin( c );
@@ -252,7 +251,7 @@ namespace boost {
             \overload
         */
         template< typename C >
-        inline BOOST_STRING_TYPENAME collection_traits<C>::result_iterator
+        inline typename collection_traits<C>::result_iterator
         end( C& c )
         {
             return collection_traits<C>::function_type::end( c );

include/boost/range/detail/collection_traits_detail.hpp

@@ -10,7 +10,6 @@
 #ifndef BOOST_RANGE_STRING_DETAIL_COLLECTION_TRAITS_HPP
 #define BOOST_RANGE_STRING_DETAIL_COLLECTION_TRAITS_HPP
 
-#include <boost/algorithm/string/config.hpp>
 #include <cstddef>
 #include <string>
 #include <boost/type_traits/is_array.hpp>
@@ -24,7 +23,6 @@
 #include <boost/mpl/vector.hpp>
 #include <boost/mpl/fold.hpp>
 #include <boost/detail/iterator.hpp>
-#include <boost/algorithm/string/yes_no_type.hpp>
 
 // Container traits implementation ---------------------------------------------------------
 
@@ -41,16 +39,16 @@ namespace boost {
             template< typename ContainerT >     
             struct default_container_traits
             {
-                typedef BOOST_STRING_TYPENAME ContainerT::value_type value_type;
-                typedef BOOST_STRING_TYPENAME ContainerT::iterator iterator;
-                typedef BOOST_STRING_TYPENAME ContainerT::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME 
+                typedef typename ContainerT::value_type value_type;
+                typedef typename ContainerT::iterator iterator;
+                typedef typename ContainerT::const_iterator const_iterator;
+                typedef typename
                     ::boost::mpl::if_< ::boost::is_const<ContainerT>,
                         const_iterator,
                         iterator 
                     >::type result_iterator;
-                typedef BOOST_STRING_TYPENAME ContainerT::difference_type difference_type;
-                typedef BOOST_STRING_TYPENAME ContainerT::size_type size_type;
+                typedef typename ContainerT::difference_type difference_type;
+                typedef typename ContainerT::size_type size_type;
                 
                 // static operations
                 template< typename C >
@@ -116,7 +114,10 @@ namespace boost {
             };
 
 // Pair container traits ---------------------------------------------------------------------
-                    
+
+            typedef double yes_type;
+            typedef char no_type;
+
             // pair selector
             template< typename T, typename U >
             yes_type is_pair_impl( const std::pair<T,U>* );
@@ -135,12 +136,12 @@ namespace boost {
             template< typename PairT >
             struct pair_container_traits
             {
-                typedef BOOST_STRING_TYPENAME PairT::first_type element_type;
+                typedef typename PairT::first_type element_type;
 
-                typedef BOOST_STRING_TYPENAME ::boost::detail::
+                typedef typename ::boost::detail::
                     iterator_traits<element_type>::value_type value_type;
                 typedef std::size_t size_type;
-                typedef BOOST_STRING_TYPENAME ::boost::detail::
+                typedef typename ::boost::detail::
                     iterator_traits<element_type>::difference_type difference_type;
 
                 typedef element_type iterator;
@@ -221,7 +222,7 @@ namespace boost {
                 template< typename TraitsT >
                 struct array_length
                 {
-                    typedef BOOST_STRING_TYPENAME 
+                    typedef typename
                         TraitsT::size_type size_type;
 
                     BOOST_STATIC_CONSTANT(
@@ -249,7 +250,7 @@ namespace boost {
                 template< typename TraitsT >
                 struct array_length
                 {
-                    typedef BOOST_STRING_TYPENAME 
+                    typedef typename
                         TraitsT::size_type size_type;
 
                     template< typename A >
@@ -276,7 +277,7 @@ namespace boost {
                 template< typename TraitsT >
                 struct array_length
                 {
-                    typedef BOOST_STRING_TYPENAME 
+                    typedef typename
                         TraitsT::size_type size_type;
 
                     template< typename A >
@@ -304,18 +305,18 @@ namespace boost {
                 typedef array_traits<T> traits_type;
 
             public:
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     traits_type::value_type value_type;
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     traits_type::iterator iterator;
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     traits_type::const_iterator const_iterator;
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     traits_type::size_type size_type;
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     traits_type::difference_type difference_type;
 
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     ::boost::mpl::if_< ::boost::is_const<T>,
                         const_iterator,
                         iterator 
@@ -323,9 +324,9 @@ namespace boost {
                 
             private:
                 // resolve array size
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     ::boost::remove_cv<value_type>::type char_type;
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     array_length_selector<char_type>::
                         BOOST_NESTED_TEMPLATE array_length<traits_type> array_length_type;
 
@@ -401,10 +402,10 @@ namespace boost {
             template<typename T>
             struct pointer_container_traits
             {
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     ::boost::remove_pointer<T>::type value_type;
 
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     ::boost::remove_cv<value_type>::type char_type;
                 typedef ::std::char_traits<char_type> char_traits;
 
@@ -413,7 +414,7 @@ namespace boost {
                 typedef std::ptrdiff_t difference_type;
                 typedef std::size_t size_type;
 
-                typedef BOOST_STRING_TYPENAME
+                typedef typename
                     ::boost::mpl::if_< ::boost::is_const<T>,
                         const_iterator,
                         iterator 

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/detail/demote_iterator_traversal_tag.hpp

@@ -79,8 +79,8 @@ BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, random_access_traversal
 template<class IteratorTraversalTag1, class IteratorTraversalTag2>
 struct demote_iterator_traversal_tag
     : inner_demote_iterator_traversal_tag<
-        typename boost::detail::pure_traversal_tag< IteratorTraversalTag1 >::type,
-        typename boost::detail::pure_traversal_tag< IteratorTraversalTag2 >::type
+        typename boost::iterators::pure_traversal_tag< IteratorTraversalTag1 >::type,
+        typename boost::iterators::pure_traversal_tag< IteratorTraversalTag2 >::type
       >
 {
 };

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 ) );
             }
         };
 
@@ -442,8 +442,8 @@ public:
             > base_type;
 
             template<class Source>
-            struct is_compatible_range
-                : is_convertible<
+            struct is_compatible_range_
+              : is_convertible<
                     BOOST_DEDUCED_TYPENAME mpl::eval_if<
                         has_range_iterator<Source>,
                         range_iterator<Source>,
@@ -454,6 +454,20 @@ public:
             {
             };
 
+            template<class Source>
+            struct is_compatible_range
+                : mpl::and_<
+                    mpl::not_<
+                        is_convertible<
+                            Source,
+                            BOOST_DEDUCED_TYPENAME base_type::iterator
+                        >
+                    >,
+                    is_compatible_range_<Source>
+                >
+            {
+            };
+
         protected:
             typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
 

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,25 @@ 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
-    };
+    struct range_size<const T > :
+        detail::range_size<T>
+    { };
 
 } // 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
 

meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "range",
+    "name": "Range",
+    "authors": [
+        "Niel Groves",
+        "Thorsten Ottosen"
+    ],
+    "description": "A new infrastructure for generic algorithms that builds on top of the new iterator concepts.",
+    "category": [
+        "Algorithms"
+    ],
+    "maintainers": [
+        "Neil Groves <neilgroves -at- googlemail.com>",
+        "Nathan Ridge <zeratul976 -at- hotmail.com>"
+    ]
+}

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/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_range.cpp

@@ -266,21 +266,18 @@ inline void test_advance()
     BOOST_CHECK_EQUAL(r3.advance_end(-1).size(), 1u);
 }
 
-boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
+struct ptr_iterator
+  : boost::iterator_adaptor<ptr_iterator, int *>
 {
-    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    ptr_iterator() {}
+    ptr_iterator(int *p) : boost::iterator_adaptor<ptr_iterator, int *>(p) {}
+private:
+    typedef void iterator; // To throw off the SFINAE mechanism in iterator_range
+};
 
-    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;
+void test_sfinae()
+{
+    boost::iterator_range<ptr_iterator> r(ptr_iterator(0), ptr_iterator(0));
 }
 
 //
@@ -313,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/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;
+}