Boost.Range merge of bug fixes and documentation

[SVN r64120]

include/boost/range/adaptor/adjacent_filtered.hpp

@@ -27,7 +27,6 @@
 
 namespace boost
 {
-
     namespace range_detail
     {
         template< class Iter, class Pred, bool default_pass >
@@ -140,10 +139,14 @@ namespace boost
 
         public:
             adjacent_filter_range( const P& p, R& r )
-            : base_range( skip_iter( boost::begin(r), boost::end(r), p),
-                          skip_iter( boost::end(r), boost::end(r), p) )
+            : base_range(skip_iter(boost::begin(r), boost::end(r), p),
+                         skip_iter(boost::end(r), boost::end(r), p))
             {
             }
+
+        private:
+            P m_pred;
+            R* m_range;
         };
 
         template< class T >

include/boost/range/adaptor/map.hpp

@@ -25,9 +25,9 @@ namespace boost
         template< class Map >
         struct select_first
         {
-            typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
-            typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type& 
-                result_type;  
+            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
+            typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
+                result_type;
 
             result_type operator()( const pair_t& r ) const
             {
@@ -38,8 +38,8 @@ namespace boost
         template< class Map >
         struct select_second_mutable
         {
-            typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
-            typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;  
+            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
+            typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
 
             result_type operator()( pair_t& r ) const
             {
@@ -50,16 +50,16 @@ namespace boost
         template< class Map >
         struct select_second_const
         {
-            typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
-            typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type& 
-                result_type;  
-            
+            typedef BOOST_DEDUCED_TYPENAME range_value<Map>::type pair_t;
+            typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
+                result_type;
+
             result_type operator()( const pair_t& r ) const
             {
                 return r.second;
             }
         };
-        
+
         template<class StdPairRng>
         class select_first_range
             : public transform_range<
@@ -78,7 +78,7 @@ namespace boost
 
             select_first_range(const base& other) : base(other) {}
         };
-        
+
         template<class StdPairRng>
         class select_second_mutable_range
             : public transform_range<
@@ -97,7 +97,7 @@ namespace boost
 
             select_second_mutable_range(const base& other) : base(other) {}
         };
-        
+
         template<class StdPairRng>
         class select_second_const_range
             : public transform_range<
@@ -116,20 +116,20 @@ namespace boost
 
             select_second_const_range(const base& other) : base(other) {}
         };
-        
+
         template< class StdPairRng >
-        inline select_first_range<StdPairRng> 
+        inline select_first_range<StdPairRng>
         operator|( const StdPairRng& r, map_keys_forwarder )
         {
-            return operator|( r, 
+            return operator|( r,
               boost::adaptors::transformed( select_first<StdPairRng>() ) );
         }
 
         template< class StdPairRng >
-        inline select_second_mutable_range<StdPairRng> 
+        inline select_second_mutable_range<StdPairRng>
         operator|( StdPairRng& r, map_values_forwarder )
         {
-            return operator|( r, 
+            return operator|( r,
           boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
         }
 
@@ -137,27 +137,27 @@ namespace boost
         inline select_second_const_range<StdPairRng>
         operator|( const StdPairRng& r, map_values_forwarder )
         {
-            return operator|( r, 
-           boost::adaptors::transformed( select_second_const<StdPairRng>() ) ); 
+            return operator|( r,
+           boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
         }
-        
+
     } // 'range_detail'
-    
+
     using range_detail::select_first_range;
     using range_detail::select_second_mutable_range;
     using range_detail::select_second_const_range;
 
     namespace adaptors
-    { 
+    {
         namespace
         {
-            const range_detail::map_keys_forwarder map_keys = 
+            const range_detail::map_keys_forwarder map_keys =
                                             range_detail::map_keys_forwarder();
 
-            const range_detail::map_values_forwarder map_values = 
+            const range_detail::map_values_forwarder map_values =
                                            range_detail::map_values_forwarder();
         }
-        
+
         template<class StdPairRange>
         inline select_first_range<StdPairRange>
         keys(const StdPairRange& rng)
@@ -165,7 +165,7 @@ namespace boost
             return select_first_range<StdPairRange>(
                 range_detail::select_first<StdPairRange>(), rng );
         }
-        
+
         template<class StdPairRange>
         inline select_second_const_range<StdPairRange>
         values(const StdPairRange& rng)
@@ -173,7 +173,7 @@ namespace boost
             return select_second_const_range<StdPairRange>(
                 range_detail::select_second_const<StdPairRange>(), rng );
         }
-        
+
         template<class StdPairRange>
         inline select_second_mutable_range<StdPairRange>
         values(StdPairRange& rng)
@@ -182,7 +182,7 @@ namespace boost
                 range_detail::select_second_mutable<StdPairRange>(), rng );
         }
     } // 'adaptors'
-    
+
 }
 
 #endif

include/boost/range/adaptor/replaced.hpp

@@ -47,7 +47,7 @@ namespace boost
         };
 
         template< class R >
-        class replace_range :
+        class replaced_range :
             public boost::iterator_range<
                 boost::transform_iterator<
                     replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
@@ -64,7 +64,7 @@ namespace boost
         public:
             typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
 
-            replace_range( R& r, value_type from, value_type to )
+            replaced_range( R& r, value_type from, value_type to )
                 : base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
                           make_transform_iterator( boost::end(r), Fn(from, to) ) )
             { }
@@ -83,23 +83,23 @@ namespace boost
         };
 
         template< class InputRng >
-        inline replace_range<InputRng>
+        inline replaced_range<InputRng>
         operator|( InputRng& r,
                    const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
         {
-            return replace_range<InputRng>(r, f.val1, f.val2);
+            return replaced_range<InputRng>(r, f.val1, f.val2);
         }
 
         template< class InputRng >
-        inline replace_range<const InputRng>
+        inline replaced_range<const InputRng>
         operator|( const InputRng& r,
                    const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
         {
-            return replace_range<const InputRng>(r, f.val1, f.val2);
+            return replaced_range<const InputRng>(r, f.val1, f.val2);
         }
     } // 'range_detail'
 
-    using range_detail::replace_range;
+    using range_detail::replaced_range;
 
     namespace adaptors
     {
@@ -111,21 +111,21 @@ namespace boost
         }
 
         template<class InputRange>
-        inline replace_range<InputRange>
+        inline replaced_range<InputRange>
         replace(InputRange& rng,
                 BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
                 BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
         {
-            return replace_range<InputRange>(rng, from, to);
+            return replaced_range<InputRange>(rng, from, to);
         }
 
         template<class InputRange>
-        inline replace_range<const InputRange>
+        inline replaced_range<const InputRange>
         replace(const InputRange& rng,
                 BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type from,
                 BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
         {
-            return replace_range<const InputRange>(rng, from ,to);
+            return replaced_range<const InputRange>(rng, from ,to);
         }
 
     } // 'adaptors'

include/boost/range/adaptor/sliced.hpp

@@ -28,14 +28,26 @@ namespace boost
         };
 
 		template< class RandomAccessRange >
-		inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+		class sliced_range : public boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+		{
+			typedef boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type > base_t;
+		public:
+			template<typename Rng, typename T, typename U>
+			sliced_range(Rng& rng, T t, U u)
+				: base_t(boost::make_iterator_range(rng, t, u - boost::size(rng)))
+			{
+			}
+		};
+
+		template< class RandomAccessRange >
+		inline sliced_range<RandomAccessRange>
 		slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
 		{
 			BOOST_ASSERT( t <= u && "error in slice indices" );
             BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
 						  "second slice index out of bounds" );
 
-			return boost::make_iterator_range( rng, t, u - boost::size(rng) );
+			return sliced_range<RandomAccessRange>(rng, t, u);
 		}
 
 		template< class RandomAccessRange >
@@ -46,23 +58,21 @@ namespace boost
 		    BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
 		                  "second slice index out of bounds" );
 
-            return boost::make_iterator_range( rng, t, u - boost::size(rng) );
+            return sliced_range<const RandomAccessRange>(rng, t, u);
 		}
 
 		template< class RandomAccessRange >
-		inline iterator_range<
-			     BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+		inline sliced_range<RandomAccessRange>
 		operator|( RandomAccessRange& r, const sliced& f )
 		{
-			return adaptors::slice( r, f.t, f.u );
+			return sliced_range<RandomAccessRange>( r, f.t, f.u );
 		}
 
 		template< class RandomAccessRange >
-		inline iterator_range<
-				 BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type >
+		inline sliced_range<const RandomAccessRange>
 		operator|( const RandomAccessRange& r, const sliced& f )
 		{
-			return adaptors::slice( r, f.t, f.u );
+			return sliced_range<const RandomAccessRange>( r, f.t, f.u );
 		}
 
     } // namespace adaptors

include/boost/range/algorithm/copy.hpp

@@ -30,7 +30,7 @@ namespace boost
 template< class SinglePassRange, class OutputIterator >
 inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
     return std::copy(boost::begin(rng),boost::end(rng),out);
 }
 

include/boost/range/algorithm/copy_backward.hpp

@@ -32,7 +32,7 @@ inline BidirectionalTraversalWriteableIterator
 copy_backward(const BidirectionalRange& rng,
               BidirectionalTraversalWriteableIterator out)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::copy_backward(boost::begin(rng), boost::end(rng), out);
 }
 

include/boost/range/algorithm/equal.hpp

@@ -159,8 +159,8 @@ namespace boost
         template< class SinglePassRange1, class SinglePassRange2 >
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
         {
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
 
             return ::boost::range_detail::equal(
                 ::boost::begin(rng1), ::boost::end(rng1),
@@ -172,8 +172,8 @@ namespace boost
         inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
                            BinaryPredicate pred )
         {
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
-            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
+            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+            BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
 
             return ::boost::range_detail::equal(
                 ::boost::begin(rng1), ::boost::end(rng1),

include/boost/range/algorithm/fill.hpp

@@ -33,6 +33,15 @@ inline ForwardRange& fill(ForwardRange& rng, const Value& val)
     return rng;
 }
 
+/// \overload
+template< class ForwardRange, class Value >
+inline const ForwardRange& fill(const ForwardRange& rng, const Value& val)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::fill(boost::begin(rng), boost::end(rng), val);
+    return rng;
+}
+
     } // namespace range
     using range::fill;
 }

include/boost/range/algorithm/fill_n.hpp

@@ -36,6 +36,16 @@ inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
     return rng;
 }
 
+/// \overload
+template< class ForwardRange, class Size, class Value >
+inline const ForwardRange& fill_n(const ForwardRange& rng, Size n, const Value& val)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
+    std::fill_n(boost::begin(rng), n, val);
+    return rng;
+}
+
     } // namespace range
     using range::fill_n;
 } // namespace boost

include/boost/range/algorithm/find.hpp

@@ -27,18 +27,33 @@ namespace boost
 ///
 /// \pre SinglePassRange is a model of the SinglePassRangeConcept
 template< class SinglePassRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+>::type
 find( SinglePassRange& rng, const Value& val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return std::find(boost::begin(rng), boost::end(rng), val);
 }
 
+/// \overload
+template< class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+find( const SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::find(boost::begin(rng), boost::end(rng), val);
+}
+
 // range_return overloads
 
 /// \overload
 template< range_return_value re, class SinglePassRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+>::type
 find( SinglePassRange& rng, const Value& val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
@@ -47,6 +62,17 @@ find( SinglePassRange& rng, const Value& val )
              rng);
 }
 
+/// \overload
+template< range_return_value re, class SinglePassRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+find( const SinglePassRange& rng, const Value& val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return range_return<const SinglePassRange,re>::
+        pack(std::find(boost::begin(rng), boost::end(rng), val),
+             rng);
+}
+
     } // namespace range
     using range::find;
 }

include/boost/range/algorithm/find_end.hpp

@@ -29,7 +29,10 @@ namespace boost
 /// \pre ForwardRange2 is a model of the ForwardRangeConcept
 /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
 template< class ForwardRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange1>,
+    BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
+>::type
 find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
@@ -39,9 +42,24 @@ find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
                          boost::begin(rng2),boost::end(rng2));
 }
 
+/// \overload
+template< class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_iterator< const ForwardRange1 >::type
+find_end(const ForwardRange1 & rng1, const ForwardRange2& rng2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2));
+}
+
 /// \overload
 template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange1>,
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
+>::type
 find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
@@ -51,9 +69,24 @@ find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
                          boost::begin(rng2),boost::end(rng2),pred);
 }
 
+/// \overload
+template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
+find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_end(boost::begin(rng1),boost::end(rng1),
+                         boost::begin(rng2),boost::end(rng2),pred);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange1>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
@@ -65,10 +98,27 @@ find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
              rng1);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange1, class ForwardRange2,
           class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange1>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
+>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
@@ -80,6 +130,21 @@ find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
              rng1);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
+find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const ForwardRange1,re>::
+        pack(std::find_end(boost::begin(rng1), boost::end(rng1),
+                           boost::begin(rng2), boost::end(rng2), pred),
+             rng1);
+}
+
     } // namespace range
     using range::find_end;
 } // namespace boost

include/boost/range/algorithm/find_first_of.hpp

@@ -29,7 +29,10 @@ namespace boost
 /// \pre ForwardRange2 is a model of the ForwardRangeConcept
 /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
 template< class SinglePassRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange1>,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+>::type
 find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
@@ -39,9 +42,24 @@ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
                               boost::begin(rng2),boost::end(rng2));
 }
 
+/// \overload
+template< class SinglePassRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2));
+}
+
 /// \overload
 template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange1>,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
+>::type
 find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
@@ -51,10 +69,25 @@ find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredica
                               boost::begin(rng2),boost::end(rng2),pred);
 }
 
+/// \overload
+template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return std::find_first_of(boost::begin(rng1),boost::end(rng1),
+                              boost::begin(rng2),boost::end(rng2),pred);
+}
+
 // range return overloads
 /// \overload
 template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange1>,
+    BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+>::type
 find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
@@ -66,10 +99,27 @@ find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
              rng1);
 }
 
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2)),
+             rng1);
+}
+
 /// \overload
 template< range_return_value re, class SinglePassRange1, class ForwardRange2,
           class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange1>,
+    BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
+>::type
 find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
               BinaryPredicate pred)
 {
@@ -82,6 +132,22 @@ find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
              rng1);
 }
 
+/// \overload
+template< range_return_value re, class SinglePassRange1, class ForwardRange2,
+          class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
+find_first_of(const SinglePassRange1 & rng1, const ForwardRange2& rng2,
+              BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
+
+    return range_return<const SinglePassRange1,re>::
+        pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
+                                boost::begin(rng2), boost::end(rng2), pred),
+             rng1);
+}
+
     } // namespace range
     using range::find_first_of;
 } // namespace boost

include/boost/range/algorithm/find_if.hpp

@@ -28,18 +28,33 @@ namespace boost
 /// \pre SinglePassRange is a model of the SinglePassRangeConcept
 /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
 template< class SinglePassRange, class UnaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
+>::type
 find_if( SinglePassRange& rng, UnaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
     return std::find_if(boost::begin(rng), boost::end(rng), pred);
 }
 
+/// \overload
+template< class SinglePassRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
+find_if( const SinglePassRange& rng, UnaryPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return std::find_if(boost::begin(rng), boost::end(rng), pred);
+}
+
 // range_return overloads
 
 /// \overload
 template< range_return_value re, class SinglePassRange, class UnaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<SinglePassRange>,
+    BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
+>::type
 find_if( SinglePassRange& rng, UnaryPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
@@ -48,6 +63,17 @@ find_if( SinglePassRange& rng, UnaryPredicate pred )
              rng);
 }
 
+/// \overload
+template< range_return_value re, class SinglePassRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
+find_if( const SinglePassRange& rng, UnaryPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+    return range_return<const SinglePassRange,re>::
+        pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
+             rng);
+}
+
     } // namespace range
     using range::find_if;
 } // namespace boost

include/boost/range/algorithm/generate.hpp

@@ -33,6 +33,15 @@ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
     return rng;
 }
 
+/// \overload
+template< class ForwardRange, class Generator >
+inline const ForwardRange& generate( const ForwardRange& rng, Generator gen )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::generate(boost::begin(rng), boost::end(rng), gen);
+    return rng;
+}
+
     } // namespace range
     using range::generate;
 } // namespace boost

include/boost/range/algorithm/heap_algorithm.hpp

@@ -34,6 +34,15 @@ inline RandomAccessRange& push_heap(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& push_heap(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::push_heap(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -43,6 +52,15 @@ inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline const RandomAccessRange& push_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
+    return rng;
+}
+
 /// \brief template function pop_heap
 ///
 /// range-based version of the pop_heap std algorithm
@@ -57,6 +75,15 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -66,6 +93,15 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
+    return rng;
+}
+
 /// \brief template function make_heap
 ///
 /// range-based version of the make_heap std algorithm
@@ -80,6 +116,15 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& make_heap(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::make_heap(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -89,6 +134,15 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline const RandomAccessRange& make_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
+    return rng;
+}
+
 /// \brief template function sort_heap
 ///
 /// range-based version of the sort_heap std algorithm
@@ -103,6 +157,15 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class Compare>
 inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
@@ -112,6 +175,15 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class Compare>
+inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng, Compare comp_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
+    return rng;
+}
+
     } // namespace range
     using range::push_heap;
     using range::pop_heap;

include/boost/range/algorithm/lower_bound.hpp

@@ -27,23 +27,52 @@ namespace boost
 ///
 /// \pre ForwardRange is a model of the ForwardRangeConcept
 template< class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+>::type
 lower_bound( ForwardRange& rng, Value val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::lower_bound(boost::begin(rng), boost::end(rng), val);
 }
+
+/// \overload
+template< class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+lower_bound( const ForwardRange& rng, Value val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val);
+}
+
 /// \overload
 template< class ForwardRange, class Value, class SortPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+>::type
 lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
 }
+
+/// \overload
+template< class ForwardRange, class Value, class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+>::type
 lower_bound( ForwardRange& rng, Value val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
@@ -51,9 +80,24 @@ lower_bound( ForwardRange& rng, Value val )
         pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
              rng);
 }
+
+/// \overload
+template< range_return_value re, class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+lower_bound( const ForwardRange& rng, Value val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
+             rng);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+>::type
 lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
@@ -62,6 +106,17 @@ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
              rng);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
+}
+
     } // namespace range
     using range::lower_bound;
 } // namespace boost

include/boost/range/algorithm/partial_sort.hpp

@@ -35,6 +35,16 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class BinaryPredicate>
 inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
@@ -47,6 +57,18 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
+    BinaryPredicate sort_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::partial_sort(boost::begin(rng), middle, boost::end(rng),
+                        sort_pred);
+    return rng;
+}
+
     } // namespace range
     using range::partial_sort;
 } // namespace boost

include/boost/range/algorithm/partial_sort_copy.hpp

@@ -32,7 +32,18 @@ template<class SinglePassRange, class RandomAccessRange>
 inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
 partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
+
+    return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2));
+}
+
+/// \overload
+template<class SinglePassRange, class RandomAccessRange>
+inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
+partial_sort_copy(const SinglePassRange& rng1, const RandomAccessRange& rng2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
 
     return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2));
@@ -45,7 +56,20 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
 partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
     BinaryPredicate pred)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
+
+    return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
+        boost::begin(rng2), boost::end(rng2), pred);
+}
+
+/// \overload
+template<class SinglePassRange, class RandomAccessRange,
+         class BinaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type
+partial_sort_copy(const SinglePassRange& rng1, const RandomAccessRange& rng2,
+    BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
 
     return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
         boost::begin(rng2), boost::end(rng2), pred);

include/boost/range/algorithm/partition.hpp

@@ -34,6 +34,15 @@ partition(ForwardRange& rng, UnaryPredicate pred)
     return std::partition(boost::begin(rng),boost::end(rng),pred);
 }
 
+/// \overload
+template<class ForwardRange, class UnaryPredicate>
+inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+partition(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::partition(boost::begin(rng),boost::end(rng),pred);
+}
+
 // range_return overloads
 
 /// \overload
@@ -47,6 +56,17 @@ partition(ForwardRange& rng, UnaryPredicate pred)
         pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange,
+          class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+partition(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return boost::range_return<const ForwardRange,re>::
+        pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
+}
+
     } // namespace range
     using range::partition;
 } // namespace boost

include/boost/range/algorithm/random_shuffle.hpp

@@ -34,6 +34,15 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::random_shuffle(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class Generator>
 inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
@@ -43,6 +52,15 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class Generator>
+inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
+    return rng;
+}
+
     } // namespace range
     using range::random_shuffle;
 } // namespace boost

include/boost/range/algorithm/remove.hpp

@@ -34,6 +34,15 @@ remove(ForwardRange& rng, const Value& val)
     return std::remove(boost::begin(rng),boost::end(rng),val);
 }
 
+/// \overload
+template< class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+remove(const ForwardRange& rng, const Value& val)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::remove(boost::begin(rng),boost::end(rng),val);
+}
+
 // range_return overloads
 
 /// \overload
@@ -47,6 +56,17 @@ remove(ForwardRange& rng, const Value& val)
         rng);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+remove(const ForwardRange& rng, const Value& val)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::remove(boost::begin(rng), boost::end(rng), val),
+        rng);
+}
+
     } // namespace range
     using range::remove;
 } // namespace boost

include/boost/range/algorithm/remove_copy.hpp

@@ -31,9 +31,9 @@ namespace boost
 /// InputIterator's value type.
 template< class SinglePassRange, class OutputIterator, class Value >
 inline OutputIterator
-remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
+remove_copy(const SinglePassRange& rng, OutputIterator out_it, const Value& val)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
     return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
 }
 

include/boost/range/algorithm/remove_copy_if.hpp

@@ -28,10 +28,10 @@ namespace boost
     /// \pre out_it is not an iterator in the range rng
     template< class SinglePassRange, class OutputIterator, class Predicate >
     inline OutputIterator
-    remove_copy_if(SinglePassRange& rng, OutputIterator out_it, Predicate pred)
+    remove_copy_if(const SinglePassRange& rng, OutputIterator out_it, Predicate pred)
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred); 
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+        return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
     }
 }
 

include/boost/range/algorithm/remove_if.hpp

@@ -35,6 +35,15 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
     return std::remove_if(boost::begin(rng), boost::end(rng), pred);
 }
 
+/// \overload
+template< class ForwardRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
+remove_if(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::remove_if(boost::begin(rng), boost::end(rng), pred);
+}
+
 // range_return overloads
 
 /// \overload
@@ -48,6 +57,17 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
         rng);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+remove_if(const ForwardRange& rng, UnaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::pack(
+        std::remove_if(boost::begin(rng), boost::end(rng), pred),
+        rng);
+}
+
     } // namespace range
     using range::remove_if;
 } // namespace boost

include/boost/range/algorithm/replace.hpp

@@ -35,6 +35,17 @@ replace(ForwardRange& rng, const Value& what,
     return rng;
 }
 
+/// \overload
+template< class ForwardRange, class Value >
+inline const ForwardRange&
+replace(const ForwardRange& rng, const Value& what,
+        const Value& with_what)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::replace(boost::begin(rng), boost::end(rng), what, with_what);
+    return rng;
+}
+
     } // namespace range
     using range::replace;
 } // namespace boost;

include/boost/range/algorithm/replace_copy.hpp

@@ -27,10 +27,10 @@ namespace boost
 /// \pre ForwardRange is a model of the ForwardRangeConcept
 template< class ForwardRange, class OutputIterator, class Value >
 inline OutputIterator
-replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
+replace_copy(const ForwardRange& rng, OutputIterator out_it, const Value& what,
         const Value& with_what)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
         what, with_what);
 }

include/boost/range/algorithm/replace_copy_if.hpp

@@ -31,10 +31,10 @@ namespace boost
 /// \pre Value is convertible to a type in OutputIterator's set of value types.
 template< class ForwardRange, class OutputIterator, class Predicate, class Value >
 inline OutputIterator
-replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
+replace_copy_if(const ForwardRange& rng, OutputIterator out_it, Predicate pred,
         const Value& with_what)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
     return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
         pred, with_what);
 }

include/boost/range/algorithm/replace_if.hpp

@@ -36,6 +36,17 @@ inline ForwardRange&
     return rng;
 }
 
+/// \overload
+template< class ForwardRange, class UnaryPredicate, class Value >
+inline const ForwardRange&
+    replace_if(const ForwardRange& rng, UnaryPredicate pred,
+               const Value& val)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
+    return rng;
+}
+
     } // namespace range
     using range::replace_if;
 } // namespace boost

include/boost/range/algorithm/reverse.hpp

@@ -34,6 +34,15 @@ inline BidirectionalRange& reverse(BidirectionalRange& rng)
     return rng;
 }
 
+/// \overload
+template<class BidirectionalRange>
+inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
+    std::reverse(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
     } // namespace range
     using range::reverse;
 } // namespace boost

include/boost/range/algorithm/reverse_copy.hpp

@@ -29,7 +29,7 @@ namespace boost
 template<class BidirectionalRange, class OutputIterator>
 inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
 {
-    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
     return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
 }
 

include/boost/range/algorithm/rotate.hpp

@@ -34,6 +34,16 @@ inline ForwardRange& rotate(ForwardRange& rng,
     return rng;
 }
 
+/// \overload
+template<class ForwardRange>
+inline const ForwardRange& rotate(const ForwardRange& rng,
+    BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    std::rotate(boost::begin(rng), middle, boost::end(rng));
+    return rng;
+}
+
     } // namespace range
     using range::rotate;
 } // namespace boost

include/boost/range/algorithm/search_n.hpp

@@ -44,7 +44,7 @@ template< class ForwardRange, class Integer, class Value >
 inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 search_n(const ForwardRange& rng, Integer count, const Value& value)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>));
     return std::search_n(boost::begin(rng), boost::end(rng), count, value);
 }
 
@@ -69,7 +69,7 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
 search_n(const ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate binary_pred)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>));
     BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type, const Value&>));
     return std::search_n(boost::begin(rng), boost::end(rng),
@@ -97,7 +97,7 @@ template< range_return_value re, class ForwardRange, class Integer,
 inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
 search_n(const ForwardRange& rng, Integer count, const Value& value)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>));
     return range_return<const ForwardRange,re>::
         pack(std::search_n(boost::begin(rng), boost::end(rng),
                            count, value),
@@ -128,7 +128,7 @@ inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
 search_n(const ForwardRange& rng, Integer count, const Value& value,
          BinaryPredicate pred)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>));
     BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
         BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type,
         const Value&>));

include/boost/range/algorithm/sort.hpp

@@ -34,6 +34,15 @@ inline RandomAccessRange& sort(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& sort(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class BinaryPredicate>
 inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
@@ -43,6 +52,15 @@ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::sort(boost::begin(rng), boost::end(rng), pred);
+    return rng;
+}
+
     } // namespace range
     using range::sort;
 } // namespace boost

include/boost/range/algorithm/stable_sort.hpp

@@ -34,6 +34,15 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange>
+inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::stable_sort(boost::begin(rng), boost::end(rng));
+    return rng;
+}
+
 /// \overload
 template<class RandomAccessRange, class BinaryPredicate>
 inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
@@ -43,6 +52,15 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate so
     return rng;
 }
 
+/// \overload
+template<class RandomAccessRange, class BinaryPredicate>
+inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
+    std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
+    return rng;
+}
+
     } // namespace range
     using range::stable_sort;
 } // namespace boost

include/boost/range/algorithm/swap_ranges.hpp

@@ -80,6 +80,51 @@ swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
     return range2;
 }
 
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline SinglePassRange2&
+swap_ranges(const SinglePassRange1& range1, SinglePassRange2& range2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange1>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
+
+    boost::range_detail::swap_ranges_impl(
+        boost::begin(range1), boost::end(range1),
+        boost::begin(range2), boost::end(range2));
+
+    return range2;
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline const SinglePassRange2&
+swap_ranges(SinglePassRange1& range1, const SinglePassRange2& range2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange2>));
+
+    boost::range_detail::swap_ranges_impl(
+        boost::begin(range1), boost::end(range1),
+        boost::begin(range2), boost::end(range2));
+
+    return range2;
+}
+
+/// \overload
+template< class SinglePassRange1, class SinglePassRange2 >
+inline const SinglePassRange2&
+swap_ranges(const SinglePassRange1& range1, const SinglePassRange2& range2)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange1>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange2>));
+
+    boost::range_detail::swap_ranges_impl(
+        boost::begin(range1), boost::end(range1),
+        boost::begin(range2), boost::end(range2));
+
+    return range2;
+}
+
     } // namespace range
     using range::swap_ranges;
 } // namespace boost

include/boost/range/algorithm/upper_bound.hpp

@@ -27,24 +27,53 @@ namespace boost
 ///
 /// \pre ForwardRange is a model of the ForwardRangeConcept
 template< class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline
+BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+>::type
 upper_bound( ForwardRange& rng, Value val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::upper_bound(boost::begin(rng), boost::end(rng), val);
 }
+
 /// \overload
+template< class ForwardRange, class Value >
+BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+upper_bound( const ForwardRange& rng, Value val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val);
+}
+
 /// \overload
 template< class ForwardRange, class Value, class SortPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+>::type
 upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
     return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
 }
+
+/// \overload
+template< class ForwardRange, class Value, class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+>::type
 upper_bound( ForwardRange& rng, Value val )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
@@ -52,10 +81,25 @@ upper_bound( ForwardRange& rng, Value val )
         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
              rng);
 }
+
+/// \overload
+template< range_return_value re, class ForwardRange, class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+upper_bound( const ForwardRange& rng, Value val )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
+             rng);
+}
+
 /// \overload
 template< range_return_value re, class ForwardRange, class Value,
           class SortPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+inline BOOST_DEDUCED_TYPENAME disable_if<
+    is_const<ForwardRange>,
+    BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+>::type
 upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
 {
     BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
@@ -64,6 +108,18 @@ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
              rng);
 }
 
+/// \overload
+template< range_return_value re, class ForwardRange, class Value,
+          class SortPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    return range_return<const ForwardRange,re>::
+        pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
+             rng);
+}
+
     } // namespace range
     using range::upper_bound;
 } // namespace boost

include/boost/range/algorithm_ext/iota.hpp

@@ -34,6 +34,19 @@ inline ForwardRange& iota( ForwardRange& rng, Value x )
     return rng;
 }
 
+template< class ForwardRange, class Value >
+inline const ForwardRange& iota( const ForwardRange& rng, Value x )
+{
+    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
+    typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type iterator_t;
+    
+    iterator_t last_target = ::boost::end(rng);
+    for (iterator_t target = ::boost::begin(rng); target != last_target; ++target, ++x)
+        *target = x;
+    
+    return rng;
+}
+
     } // namespace range
     using range::iota;
 } // namespace boost

include/boost/range/algorithm_ext/is_sorted.hpp

@@ -51,7 +51,7 @@ template<class SinglePassRange>
 inline bool is_sorted(const SinglePassRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>));
+    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
     return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
 }
 
@@ -59,8 +59,8 @@ inline bool is_sorted(const SinglePassRange& rng)
 template<class SinglePassRange, class BinaryPredicate>
 inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
 {
-    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>));
+    BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
+    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
     return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
 }
 

include/boost/range/algorithm_ext/overwrite.hpp

@@ -50,6 +50,33 @@ inline void overwrite( const SinglePassRange1& from, SinglePassRange2& to )
     }
 }
 
+template< class SinglePassRange1, class SinglePassRange2 >
+inline void overwrite( const SinglePassRange1& from, const SinglePassRange2& to )
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+    BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
+
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
+        i = boost::begin(from), e = boost::end(from);
+
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type
+        out = boost::begin(to);
+
+#ifndef NDEBUG
+    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type
+        last_out = boost::end(to);
+#endif
+
+    for( ; i != e; ++out, ++i )
+    {
+#ifndef NDEBUG
+        BOOST_ASSERT( out != last_out
+            && "out of bounds in boost::overwrite()" );
+#endif
+        *out = *i;
+    }
+}
+
     } // namespace range
     using range::overwrite;
 } // namespace boost

include/boost/range/detail/join_iterator.hpp

@@ -12,9 +12,9 @@
 #define BOOST_RANGE_DETAIL_JOIN_ITERATOR_HPP_INCLUDED
 
 #include <iterator>
+#include <boost/assert.hpp>
 #include <boost/iterator/iterator_traits.hpp>
 #include <boost/iterator/iterator_facade.hpp>
-#include <boost/intrusive_ptr.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/empty.hpp>
@@ -30,21 +30,6 @@ namespace boost
 template<typename Iterator1, typename Iterator2>
 struct join_iterator_link
 {
-private:
-    class reference_count_t
-    {
-    public:
-        reference_count_t() : m_count(0u) {}
-        reference_count_t(const reference_count_t&) : m_count(0u) {}
-        reference_count_t& operator=(const reference_count_t&) { return *this; }
-
-        void increment() { ++m_count; }
-        bool decrement() { return --m_count ? false : true; }
-
-    private:
-        unsigned int m_count;
-    };
-
 public:
     join_iterator_link(Iterator1 last1, Iterator2 first2)
         :    last1(last1)
@@ -52,38 +37,13 @@ public:
     {
     }
 
-    void add_reference() const
-    {
-        count.increment();
-    }
-
-    bool release_reference() const
-    {
-        return count.decrement();
-    }
-
     Iterator1 last1;
     Iterator2 first2;
 
 private:
     join_iterator_link() /* = delete */ ;
-
-    mutable reference_count_t count;
 };
 
-template<typename Iterator1, typename Iterator2>
-inline void intrusive_ptr_add_ref(const join_iterator_link<Iterator1,Iterator2>* p)
-{
-    p->add_reference();
-}
-
-template<typename Iterator1, typename Iterator2>
-inline void intrusive_ptr_release(const join_iterator_link<Iterator1,Iterator2>* p)
-{
-    if (p->release_reference())
-        delete p;
-}
-
 class join_iterator_begin_tag {};
 class join_iterator_end_tag {};
 
@@ -174,12 +134,16 @@ public:
     typedef Iterator1 iterator1_t;
     typedef Iterator2 iterator2_t;
 
-    join_iterator() : m_section(0u) {}
+    join_iterator()
+        : m_section(0u)
+        , m_it(0u, iterator1_t(), iterator2_t())
+        , m_link(link_t(iterator1_t(), iterator2_t()))
+    {}
 
     join_iterator(unsigned int section, Iterator1 current1, Iterator1 last1, Iterator2 first2, Iterator2 current2)
         : m_section(section)
         , m_it(section, current1, current2)
-        , m_link(new link_t(last1, first2))
+        , m_link(link_t(last1, first2))
         {
         }
 
@@ -187,7 +151,7 @@ public:
     join_iterator(Range1& r1, Range2& r2, join_iterator_begin_tag)
         : m_section(boost::empty(r1) ? 1u : 0u)
         , m_it(boost::empty(r1) ? 1u : 0u, boost::begin(r1), boost::begin(r2))
-        , m_link(new link_t(boost::end(r1), boost::begin(r2)))
+        , m_link(link_t(boost::end(r1), boost::begin(r2)))
     {
     }
 
@@ -195,7 +159,7 @@ public:
     join_iterator(const Range1& r1, const Range2& r2, join_iterator_begin_tag)
         : m_section(boost::empty(r1) ? 1u : 0u)
         , m_it(boost::empty(r1) ? 1u : 0u, boost::const_begin(r1), boost::const_begin(r2))
-        , m_link(new link_t(boost::const_end(r1), boost::const_begin(r2)))
+        , m_link(link_t(boost::const_end(r1), boost::const_begin(r2)))
     {
     }
 
@@ -203,7 +167,7 @@ public:
     join_iterator(Range1& r1, Range2& r2, join_iterator_end_tag)
         : m_section(1u)
         , m_it(1u, boost::end(r1), boost::end(r2))
-        , m_link(new link_t(boost::end(r1), boost::begin(r2)))
+        , m_link(link_t(boost::end(r1), boost::begin(r2)))
     {
     }
 
@@ -211,7 +175,7 @@ public:
     join_iterator(const Range1& r1, const Range2& r2, join_iterator_end_tag)
         : m_section(1u)
         , m_it(1u, boost::const_end(r1), boost::const_end(r2))
-        , m_link(new link_t(boost::const_end(r1), boost::const_begin(r2)))
+        , m_link(link_t(boost::const_end(r1), boost::const_begin(r2)))
     {
     }
 
@@ -223,9 +187,9 @@ private:
         else
         {
             ++m_it.it1();
-            if (m_it.it1() == m_link->last1)
+            if (m_it.it1() == m_link.last1)
             {
-                m_it.it2() = m_link->first2;
+                m_it.it2() = m_link.first2;
                 m_section = 1u;
             }
         }
@@ -235,9 +199,9 @@ private:
     {
         if (m_section)
         {
-            if (m_it.it2() == m_link->first2)
+            if (m_it.it2() == m_link.first2)
             {
-                m_it.it1() = boost::prior(m_link->last1);
+                m_it.it1() = boost::prior(m_link.last1);
                 m_section = 0u;
             }
             else
@@ -275,8 +239,8 @@ private:
                 result = other.m_it.it2() - m_it.it2();
             else
             {
-                result = (m_link->first2 - m_it.it2())
-                       + (other.m_it.it1() - m_link->last1);
+                result = (m_link.first2 - m_it.it2())
+                       + (other.m_it.it1() - m_link.last1);
 
                 BOOST_ASSERT( result <= 0 );
             }
@@ -285,8 +249,8 @@ private:
         {
             if (other.m_section)
             {
-                result = (m_link->last1 - m_it.it1())
-                       + (other.m_it.it2() - m_link->first2);
+                result = (m_link.last1 - m_it.it1())
+                       + (other.m_it.it2() - m_link.first2);
             }
             else
                 result = other.m_it.it1() - m_it.it1();
@@ -300,7 +264,7 @@ private:
         BOOST_ASSERT( m_section == 1u );
         if (offset < 0)
         {
-            difference_t r2_dist = m_link->first2 - m_it.it2();
+            difference_t r2_dist = m_link.first2 - m_it.it2();
             BOOST_ASSERT( r2_dist <= 0 );
             if (offset >= r2_dist)
                 std::advance(m_it.it2(), offset);
@@ -308,7 +272,7 @@ private:
             {
                 difference_t r1_dist = offset - r2_dist;
                 BOOST_ASSERT( r1_dist <= 0 );
-                m_it.it1() = m_link->last1 + r1_dist;
+                m_it.it1() = m_link.last1 + r1_dist;
                 m_section = 0u;
             }
         }
@@ -322,7 +286,7 @@ private:
         BOOST_ASSERT( m_section == 0u );
         if (offset > 0)
         {
-            difference_t r1_dist = m_link->last1 - m_it.it1();
+            difference_t r1_dist = m_link.last1 - m_it.it1();
             BOOST_ASSERT( r1_dist >= 0 );
             if (offset < r1_dist)
                 std::advance(m_it.it1(), offset);
@@ -330,7 +294,7 @@ private:
             {
                 difference_t r2_dist = offset - r1_dist;
                 BOOST_ASSERT( r2_dist >= 0 );
-                m_it.it2() = m_link->first2 + r2_dist;
+                m_it.it2() = m_link.first2 + r2_dist;
                 m_section = 1u;
             }
         }
@@ -340,7 +304,7 @@ private:
 
     unsigned int m_section;
     iterator_union m_it;
-    intrusive_ptr<const link_t> m_link;
+    link_t m_link;
 
     friend class ::boost::iterator_core_access;
 };

include/boost/range/irange.hpp

@@ -173,28 +173,54 @@ namespace boost
     } // namespace range_detail
 
     template<typename Integer>
-    iterator_range< range_detail::integer_iterator<Integer> >
-        irange(Integer first, Integer last)
+    class integer_range
+        : public iterator_range< range_detail::integer_iterator<Integer> >
+    {
+        typedef range_detail::integer_iterator<Integer> iterator_t;
+        typedef iterator_range<iterator_t> base_t;
+    public:
+        integer_range(Integer first, Integer last)
+            : base_t(iterator_t(first), iterator_t(last))
+        {
+        }
+    };
+
+    template<typename Integer>
+    class strided_integer_range
+    : public iterator_range< range_detail::integer_iterator_with_step<Integer> >
+    {
+        typedef range_detail::integer_iterator_with_step<Integer> iterator_t;
+        typedef iterator_range<iterator_t> base_t;
+    public:
+        template<typename Iterator>
+        strided_integer_range(Iterator first, Iterator last)
+            : base_t(first, last)
+        {
+        }
+    };
+
+    template<typename Integer>
+    integer_range<Integer>
+    irange(Integer first, Integer last)
     {
         BOOST_ASSERT( first <= last );
-        return boost::iterator_range< range_detail::integer_iterator<Integer> >(
-                range_detail::integer_iterator<Integer>(first),
-                range_detail::integer_iterator<Integer>(last));
+        return integer_range<Integer>(first, last);
     }
 
     template<typename Integer, typename StepSize>
-    iterator_range< range_detail::integer_iterator_with_step<Integer> >
+    strided_integer_range<Integer>
         irange(Integer first, Integer last, StepSize step_size)
     {
         BOOST_ASSERT( step_size != 0 );
         BOOST_ASSERT( (step_size > 0) ? (last >= first) : (last <= first) );
+
         typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;
 
         const std::ptrdiff_t last_step
             = (static_cast<std::ptrdiff_t>(last) - static_cast<std::ptrdiff_t>(first))
             / (static_cast<std::ptrdiff_t>(step_size));
 
-        return boost::iterator_range< iterator_t >(
+        return strided_integer_range<Integer>(
             iterator_t(first, 0, step_size),
             iterator_t(first, last_step, step_size));
     }

include/boost/range/join.hpp

@@ -18,49 +18,64 @@
 
 namespace boost
 {
+    namespace range_detail
+    {
 
 template<class SinglePassRange1, class SinglePassRange2>
-iterator_range<range_detail::join_iterator<
-    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-    BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
-    BOOST_DEDUCED_TYPENAME add_const<
-        BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type>
->
+class joined_type
+{
+public:
+    typedef iterator_range<
+        range_detail::join_iterator<
+            BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+            BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+            BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type
+        >
+    > type;
+};
+
+    } // namespace range_detail
+
+template<class SinglePassRange1, class SinglePassRange2>
+class joined_range
+    : public range_detail::joined_type<SinglePassRange1, SinglePassRange2>::type
+{
+    typedef range_detail::join_iterator<
+        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
+        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
+        BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type
+        > iterator_t;
+
+    typedef BOOST_DEDUCED_TYPENAME range_detail::joined_type<
+                    SinglePassRange1, SinglePassRange2>::type base_t;
+public:
+    joined_range(SinglePassRange1& rng1, SinglePassRange2& rng2)
+        : base_t(
+            iterator_t(rng1, rng2, range_detail::join_iterator_begin_tag()),
+            iterator_t(rng1, rng2, range_detail::join_iterator_end_tag())
+        )
+    {
+    }
+};
+
+template<class SinglePassRange1, class SinglePassRange2>
+joined_range<const SinglePassRange1, const SinglePassRange2>
 join(const SinglePassRange1& r1, const SinglePassRange2& r2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
 
-    typedef range_detail::join_iterator<
-                BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
-                BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
-                BOOST_DEDUCED_TYPENAME add_const<
-                    BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type> iterator_t;
-
-    return iterator_range<iterator_t>(
-        iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
-        iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
+    return joined_range<const SinglePassRange1, const SinglePassRange2>(r1, r2);
 }
 
 template<class SinglePassRange1, class SinglePassRange2>
-iterator_range<range_detail::join_iterator<
-    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-    BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
-    BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
->
+joined_range<SinglePassRange1, SinglePassRange2>
 join(SinglePassRange1& r1, SinglePassRange2& r2)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
 
-    typedef range_detail::join_iterator<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
-        BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
-
-    return iterator_range<iterator_t>(
-        iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
-        iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
+    return joined_range<SinglePassRange1, SinglePassRange2>(r1, r2);
 }
 
 } // namespace boost

include/boost/range/numeric.hpp

@@ -7,13 +7,13 @@
 // 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)
-// 
+//
 
 // Copyright 2006 Thorsten Ottosen.
 // 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)
-// 
+//
 // Copyright 2004 Eric Niebler.
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -31,6 +31,7 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
+#include <boost/range/distance.hpp>
 #include <numeric>
 
 
@@ -39,14 +40,14 @@ namespace boost
     template< class SinglePassRange, class Value >
     inline Value accumulate( const SinglePassRange& rng, Value init )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
         return std::accumulate( boost::begin(rng), boost::end(rng), init );
     }
 
     template< class SinglePassRange, class Value, class BinaryOperation >
     inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
         return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
     }
 
@@ -54,42 +55,42 @@ namespace boost
     template< class SinglePassRange1, class SinglePassRange2, class Value >
     inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
         BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
-        return std::inner_product( boost::begin(rng1), boost::end(rng1), 
-            boost::begin(rng2), init ); 
+        return std::inner_product( boost::begin(rng1), boost::end(rng1),
+            boost::begin(rng2), init );
     }
 
     template< class SinglePassRange1,
               class SinglePassRange2,
-              class Value, 
+              class Value,
               class BinaryOperation1, class BinaryOperation2 >
     inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
-                                Value init, 
+                                Value init,
                                 BinaryOperation1 op1, BinaryOperation2 op2 )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
         BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
 
-        return std::inner_product( boost::begin(rng1), boost::end(rng1), 
-                                   boost::begin(rng2), init, op1, op2 ); 
+        return std::inner_product( boost::begin(rng1), boost::end(rng1),
+                                   boost::begin(rng2), init, op1, op2 );
     }
 
     template< class SinglePassRange, class OutputIterator >
-    inline OutputIterator partial_sum ( const SinglePassRange& rng, 
+    inline OutputIterator partial_sum ( const SinglePassRange& rng,
                                         OutputIterator result )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
         return std::partial_sum( boost::begin(rng), boost::end(rng), result );
     }
 
     template< class SinglePassRange, class OutputIterator, class BinaryOperation >
-    inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result, 
+    inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
                                         BinaryOperation op )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
         return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
     }
 
@@ -97,8 +98,8 @@ namespace boost
     inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
                                                 OutputIterator result )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::adjacent_difference( boost::begin(rng), boost::end(rng), 
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
+        return std::adjacent_difference( boost::begin(rng), boost::end(rng),
                                          result );
     }
 
@@ -107,11 +108,11 @@ namespace boost
                                                 OutputIterator result,
                                                 BinaryOperation op )
     {
-        boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
-        return std::adjacent_difference( boost::begin(rng), boost::end(rng), 
+        BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
+        return std::adjacent_difference( boost::begin(rng), boost::end(rng),
                                          result, op );
     }
-    
+
 }
 
 #endif