Boost.Range fixes for compilers that were having problems picking between const and mutable range overloads of range algorithms.

[SVN r61028]

doc/reference/algorithm/find.qbk

@@ -7,10 +7,6 @@ template<class SinglePassRange, class Value>
 typename range_iterator<SinglePassRange>::type
 find(SinglePassRange& rng, Value val);
 
-template<class SinglePassRange, class Value>
-typename range_iterator<const SinglePassRange>::type
-find(const SinglePassRange& rng, Value val);
-
 template<
     range_return_value re,
     class SinglePassRange,
@@ -18,14 +14,6 @@ template<
     >
 typename range_return<SinglePassRange, re>::type
 find(SinglePassRange& rng, Value val);
-
-template<
-    range_return_value re,
-    class SinglePassRange,
-    class Value
-    >
-typename range_return<const SinglePassRange, re>::type
-find(const SinglePassRange& rng, Value val);
 ``
 
 [heading Description]

doc/reference/algorithm/find_end.qbk

@@ -7,10 +7,6 @@ template<class ForwardRange1, class ForwardRange2>
 typename range_iterator<ForwardRange1>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2);
 
-template<class ForwardRange1, class ForwardRange2>
-typename range_iterator<const ForwardRange1>::type
-find_end(const ForwardRange1& rng1, const ForwardRange2& rng2);
-
 template<
     class ForwardRange1,
     class ForwardRange2,
@@ -19,15 +15,6 @@ template<
 typename range_iterator<ForwardRange1>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
 
-template<
-    class ForwardRange1,
-    class ForwardRange2,
-    class BinaryPredicate
-    >
-typename range_iterator<const ForwardRange1>::type
-find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
-
-
 template<
     range_return_value re,
     class ForwardRange1,
@@ -36,14 +23,6 @@ template<
 typename range_return<ForwardRange1, re>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2);
 
-template<
-    range_return_value re,
-    class ForwardRange1,
-    class ForwardRange2
-    >
-typename range_return<const ForwardRange1, re>::type
-find_end(const ForwardRange1& rng1, const ForwardRange2& rng2);
-
 template<
     range_return_value re,
     class ForwardRange1,
@@ -52,15 +31,6 @@ template<
     >
 typename range_return<ForwardRange1, re>::type
 find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
-
-template<
-    range_return_value re,
-    class ForwardRange1,
-    class ForwardRange2,
-    class BinaryPredicate
-    >
-typename range_return<const ForwardRange1, re>::type
-find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
 ``
 
 [heading Description]

doc/reference/algorithm/find_first_of.qbk

@@ -7,10 +7,6 @@ template<class SinglePassRange1, class ForwardRange2>
 typename range_iterator<SinglePassRange1>::type
 find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2);
 
-template<class SinglePassRange1, class ForwardRange2>
-typename range_iterator<const SinglePassRange1>::type
-find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2);
-
 template<
     class SinglePassRange1,
     class ForwardRange2,
@@ -19,15 +15,6 @@ template<
 typename range_iterator<SinglePassRange1>::type
 find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
 
-template<
-    class SinglePassRange1,
-    class ForwardRange2,
-    class BinaryPredicate
-    >
-typename range_iterator<const SinglePassRange1>::type
-find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
-
-
 template<
     range_return_value re,
     class SinglePassRange1,
@@ -36,14 +23,6 @@ template<
 typename range_return<SinglePassRange1, re>::type
 find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2);
 
-template<
-    range_return_value re,
-    class SinglePassRange1,
-    class ForwardRange2
-    >
-typename range_return<const SinglePassRange1, re>::type
-find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2);
-
 template<
     range_return_value re,
     class SinglePassRange1,
@@ -52,15 +31,6 @@ template<
     >
 typename range_return<SinglePassRange1, re>::type
 find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
-
-template<
-    range_return_value re,
-    class SinglePassRange1,
-    class ForwardRange2,
-    class BinaryPredicate
-    >
-typename range_return<const SinglePassRange1, re>::type
-find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred);
 ``
 
 [heading Description]

doc/reference/algorithm/find_if.qbk

@@ -7,10 +7,6 @@ template<class SinglePassRange, class UnaryPredicate>
 typename range_iterator<SinglePassRange>::type
 find_if(SinglePassRange& rng, UnaryPredicate pred);
 
-template<class SinglePassRange, class UnaryPredicate>
-typename range_iterator<const SinglePassRange>::type
-find_if(const SinglePassRange& rng, UnaryPredicate pred);
-
 template<
     range_return_value re,
     class SinglePassRange,
@@ -18,14 +14,6 @@ template<
     >
 typename range_return<SinglePassRange, re>::type
 find_if(SinglePassRange& rng, UnaryPredicate pred);
-
-template<
-    range_return_value re,
-    class SinglePassRange,
-    class UnaryPredicate
-    >
-typename range_return<const SinglePassRange, re>::type
-find_if(const SinglePassRange& rng, UnaryPredicate pred);
 ``
 
 [heading Description]

doc/reference/algorithm/lower_bound.qbk

@@ -7,10 +7,6 @@ template<class ForwardRange, class Value>
 typename range_iterator<ForwardRange>::type
 lower_bound(ForwardRange& rng, Value val);
 
-template<class ForwardRange, class Value>
-typename range_iterator<const ForwardRange>::type
-lower_bound(const ForwardRange& rng, Value val);
-
 template<
     range_return_value re,
     class ForwardRange,
@@ -18,14 +14,6 @@ template<
     >
 typename range_return<ForwardRange, re>::type
 lower_bound(ForwardRange& rng, Value val);
-
-template<
-    range_return_value re,
-    class ForwardRange,
-    class Value
-    >
-typename range_return<const ForwardRange, re>::type
-lower_bound(const ForwardRange& rng, Value val);
 ``
 
 [heading Description]

doc/reference/algorithm/upper_bound.qbk

@@ -7,10 +7,6 @@ template<class ForwardRange, class Value>
 typename range_iterator<ForwardRange>::type
 upper_bound(ForwardRange& rng, Value val);
 
-template<class ForwardRange, class Value>
-typename range_iterator<const ForwardRange>::type
-upper_bound(const ForwardRange& rng, Value val);
-
 template<
     range_return_value re,
     class ForwardRange,
@@ -18,14 +14,6 @@ template<
     >
 typename range_return<ForwardRange, re>::type
 upper_bound(ForwardRange& rng, Value val);
-
-template<
-    range_return_value re,
-    class ForwardRange,
-    class Value
-    >
-typename range_return<const ForwardRange, re>::type
-upper_bound(const ForwardRange& rng, Value val);
 ``
 
 [heading Description]

include/boost/range/algorithm/find.hpp

@@ -33,14 +33,6 @@ find( SinglePassRange& rng, const Value& val )
     BOOST_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_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-    return std::find(boost::begin(rng), boost::end(rng), val);
-}
 
 // range_return overloads
 
@@ -54,16 +46,6 @@ find( SinglePassRange& rng, const Value& val )
         pack(std::find(boost::begin(rng), boost::end(rng), 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_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

@@ -30,7 +30,7 @@ namespace boost
 /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
 template< class ForwardRange1, class ForwardRange2 >
 inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
-find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
+find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
 {
     BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
     BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
@@ -39,23 +39,10 @@ find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
                          boost::begin(rng2),boost::end(rng2));
 }
 
-/// \overload
-template< class ForwardRange1, class ForwardRange2 >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
-find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
-{
-
-    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_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
-find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
+find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
 {
     BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
     BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
@@ -64,18 +51,6 @@ find_end(ForwardRange1 & rng1, ForwardRange2 const & 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(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
-{
-    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_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
@@ -90,20 +65,6 @@ 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_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_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 >
@@ -119,22 +80,6 @@ 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_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
-    BOOST_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

@@ -39,18 +39,6 @@ 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(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
-{
-    BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_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
@@ -63,19 +51,6 @@ 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_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_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 >
@@ -91,20 +66,6 @@ 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_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_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 >
@@ -121,22 +82,6 @@ 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_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
-    BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<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

@@ -34,14 +34,6 @@ find_if( SinglePassRange& rng, UnaryPredicate pred )
     BOOST_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_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-    return std::find_if(boost::begin(rng), boost::end(rng), pred);
-}
 
 // range_return overloads
 
@@ -55,16 +47,6 @@ find_if( SinglePassRange& rng, UnaryPredicate pred )
         pack(std::find_if(boost::begin(rng), boost::end(rng), 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_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;

include/boost/range/algorithm/lower_bound.hpp

@@ -34,14 +34,6 @@ lower_bound( ForwardRange& rng, Value val )
     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_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
 lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
@@ -50,14 +42,6 @@ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
     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_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
 lower_bound( ForwardRange& rng, Value val )
@@ -68,16 +52,6 @@ lower_bound( ForwardRange& rng, Value 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_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
 lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
@@ -87,16 +61,6 @@ lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
         pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, 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_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;

include/boost/range/algorithm/upper_bound.hpp

@@ -34,13 +34,6 @@ upper_bound( ForwardRange& rng, Value val )
     return std::upper_bound(boost::begin(rng), boost::end(rng), val);
 }
 /// \overload
-template< class ForwardRange, class Value >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
-upper_bound( const ForwardRange& rng, Value val )
-{
-    BOOST_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
@@ -50,14 +43,6 @@ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
     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_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
 upper_bound( ForwardRange& rng, Value val )
@@ -68,16 +53,6 @@ upper_bound( ForwardRange& rng, Value 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_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
@@ -88,17 +63,6 @@ upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
         pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, 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_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;

test/algorithm_test/find.cpp

@@ -86,6 +86,10 @@ namespace boost
             test_find_container< const std::vector<int> >();
             test_find_container< const std::list<int> >();
             test_find_container< const std::deque<int> >();
+
+            std::vector<int> vi;
+            const std::vector<int>& cvi = vi;
+            std::vector<int>::const_iterator it = boost::find(vi, 0);
         }
     }
 }

test/sub_range.cpp

@@ -23,36 +23,33 @@
 #include <string>
 #include <vector>
 
-using namespace boost;
-using namespace std;
-
 void check_sub_range()
 {
 
-    typedef string::iterator               iterator;
+    typedef std::string::iterator                 iterator;
-    typedef string::const_iterator         const_iterator;
+    typedef std::string::const_iterator           const_iterator;
-    typedef iterator_range<iterator>       irange;
+    typedef boost::iterator_range<iterator>       irange;
-    typedef iterator_range<const_iterator> cirange;
+    typedef boost::iterator_range<const_iterator> cirange;
-    string       str  = "hello world";
+    std::string       str  = "hello world";
-    const string cstr = "const world";
+    const std::string cstr = "const world";
-    irange r    = make_iterator_range( str );
+    irange r    = boost::make_iterator_range( str );
-    r           = make_iterator_range( str.begin(), str.end() );
+    r           = boost::make_iterator_range( str.begin(), str.end() );
-    cirange r2  = make_iterator_range( cstr );
+    cirange r2  = boost::make_iterator_range( cstr );
-    r2          = make_iterator_range( cstr.begin(), cstr.end() );
+    r2          = boost::make_iterator_range( cstr.begin(), cstr.end() );
-    r2          = make_iterator_range( str );
+    r2          = boost::make_iterator_range( str );
 
-    typedef sub_range<string>       srange;
+    typedef boost::sub_range<std::string>       srange;
-    typedef sub_range<const string> csrange;
+    typedef boost::sub_range<const std::string> csrange;
     srange s     = r;
     BOOST_CHECK( r == r );
     BOOST_CHECK( s == r );
-    s            = make_iterator_range( str );
+    s            = boost::make_iterator_range( str );
     csrange s2   = r;
     s2           = r2;
-    s2           = make_iterator_range( cstr );
+    s2           = boost::make_iterator_range( cstr );
     BOOST_CHECK( r2 == r2 );
     BOOST_CHECK( s2 != r2 );
-    s2           = make_iterator_range( str );
+    s2           = boost::make_iterator_range( str );
     BOOST_CHECK( !(s != s) );
 
     BOOST_CHECK( r.begin() == s.begin() );
@@ -82,10 +79,10 @@ void check_sub_range()
         BOOST_CHECK( false );
 //#endif
 
-    cout << r << r2 << s << s2;
+    std::cout << r << r2 << s << s2;
 
-    string res  = copy_range<string>( r );
+    std::string res  = boost::copy_range<std::string>( r );
-    BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
+    BOOST_CHECK_EQUAL_COLLECTIONS( res.begin(), res.end(), r.begin(), r.end() );
 
     r.empty();
     s.empty();
@@ -107,44 +104,43 @@ void check_sub_range()
     //BOOST_CHECK( empty( singular_srange ) );
     //
 
-    srange rr = make_iterator_range( str );
+    srange rr = boost::make_iterator_range( str );
     BOOST_CHECK( rr.equal( r ) );
 
-    rr  = make_iterator_range( str.begin(), str.begin() + 5 );
+    rr  = boost::make_iterator_range( str.begin(), str.begin() + 5 );
-    BOOST_CHECK( rr == as_literal("hello") );
+    BOOST_CHECK( rr == boost::as_literal("hello") );
-    BOOST_CHECK( rr != as_literal("hell") );
+    BOOST_CHECK( rr != boost::as_literal("hell") );
-    BOOST_CHECK( rr < as_literal("hello dude") );
+    BOOST_CHECK( rr < boost::as_literal("hello dude") );
-    BOOST_CHECK( as_literal("hello") == rr );
+    BOOST_CHECK( boost::as_literal("hello") == rr );
-    BOOST_CHECK( as_literal("hell")  != rr );
+    BOOST_CHECK( boost::as_literal("hell")  != rr );
-    BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
+    BOOST_CHECK( ! (boost::as_literal("hello dude") < rr ) );
 
     irange rrr = rr;
     BOOST_CHECK( rrr == rr );
     BOOST_CHECK( !( rrr != rr ) );
     BOOST_CHECK( !( rrr < rr ) );
 
-    const irange cr = make_iterator_range( str );
+    const irange cr = boost::make_iterator_range( str );
     BOOST_CHECK_EQUAL( cr.front(), 'h' );
     BOOST_CHECK_EQUAL( cr.back(), 'd' );
     BOOST_CHECK_EQUAL( cr[1], 'e' );
     BOOST_CHECK_EQUAL( cr(1), 'e' );
 
-    rrr = make_iterator_range( str, 1, -1 );
+    rrr = boost::make_iterator_range( str, 1, -1 );
-    BOOST_CHECK( rrr == as_literal("ello worl") );
+    BOOST_CHECK( rrr == boost::as_literal("ello worl") );
-    rrr = make_iterator_range( rrr, -1, 1 );
+    rrr = boost::make_iterator_range( rrr, -1, 1 );
     BOOST_CHECK( rrr == str );
     rrr.front() = 'H';
     rrr.back()  = 'D';
     rrr[1]      = 'E';
-    BOOST_CHECK( rrr == as_literal("HEllo worlD") );
+    BOOST_CHECK( rrr == boost::as_literal("HEllo worlD") );
 }
 
 #include <boost/test/unit_test.hpp>
-using boost::unit_test::test_suite;
 
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
+    boost::unit_test::test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
 
     test->add( BOOST_TEST_CASE( &check_sub_range ) );