feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

Boost.Range removed redundant overloads, increased compiler support, and made return types consistent.

Browse Source 
[SVN r61281]
This commit is contained in:
Neil Groves
2010-04-14 22:16:11 +00:00
parent 22fcae4fcb
commit cf63ba0dc9
32 changed files with 37 additions and 821 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
include/boost/range/algorithm/adjacent_find.hpp
View File

@ -28,8 +28,8 @@ namespace boost
/// ///
/// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< typename ForwardRange > template< class ForwardRange >
inline typename range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng) adjacent_find(ForwardRange & rng)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@ -37,43 +37,19 @@ adjacent_find(ForwardRange & rng)
} }
/// \overload /// \overload
template< typename ForwardRange > template< class ForwardRange, class BinaryPredicate >
inline typename range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
adjacent_find(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::adjacent_find(boost::begin(rng),boost::end(rng));
}
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng, BinaryPredicate pred) adjacent_find(ForwardRange & rng, BinaryPredicate pred)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
typename range_value<ForwardRange>::type>));
return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
}
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type,
typename range_value<const ForwardRange>::type>));
return std::adjacent_find(boost::begin(rng),boost::end(rng),pred); return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
} }
// range_return overloads // range_return overloads
/// \overload /// \overload
template< range_return_value re, typename ForwardRange > template< range_return_value re, class ForwardRange >
inline typename range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng) adjacent_find(ForwardRange & rng)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@ -83,41 +59,16 @@ adjacent_find(ForwardRange & rng)
} }
/// \overload /// \overload
template< range_return_value re, typename ForwardRange > template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
adjacent_find(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
rng);
}
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange& rng, BinaryPredicate pred) adjacent_find(ForwardRange& rng, BinaryPredicate pred)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
typename range_value<ForwardRange>::type>));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng); rng);
} }
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng);
}
} // namespace range } // namespace range
using range::adjacent_find; using range::adjacent_find;
} // namespace boost } // namespace boost

9
include/boost/range/algorithm/count.hpp
View File

@ -27,15 +27,6 @@ namespace boost
/// ///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre SinglePassRange is a model of the SinglePassRangeConcept
template< class SinglePassRange, class Value > template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
count(const SinglePassRange& rng, const Value& val) count(const SinglePassRange& rng, const Value& val)
{ {

9
include/boost/range/algorithm/count_if.hpp
View File

@ -28,15 +28,6 @@ namespace boost
/// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate > template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
count_if(SinglePassRange& rng, UnaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
count_if(const SinglePassRange& rng, UnaryPredicate pred) count_if(const SinglePassRange& rng, UnaryPredicate pred)
{ {

24
include/boost/range/algorithm/equal_range.hpp
View File

@ -37,18 +37,6 @@ equal_range(ForwardRange& rng, const Value& val)
return std::equal_range(boost::begin(rng), boost::end(rng), val); return std::equal_range(boost::begin(rng), boost::end(rng), val);
} }
/// \overload
template<class ForwardRange, class Value>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
/// \overload /// \overload
template<class ForwardRange, class Value, class SortPredicate> template<class ForwardRange, class Value, class SortPredicate>
inline std::pair< inline std::pair<
@ -61,18 +49,6 @@ equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
} }
/// \overload
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
} // namespace range } // namespace range
using range::equal_range; using range::equal_range;
} // namespace boost } // namespace boost

8
include/boost/range/algorithm/for_each.hpp
View File

@ -33,14 +33,6 @@ inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
return std::for_each(boost::begin(rng),boost::end(rng),fun); return std::for_each(boost::begin(rng),boost::end(rng),fun);
} }
/// \overload
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(const SinglePassRange& rng, UnaryFunction fun)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::for_each(boost::begin(rng), boost::end(rng), fun);
}
} // namespace range } // namespace range
using range::for_each; using range::for_each;
} // namespace boost } // namespace boost

9
include/boost/range/algorithm/generate.hpp
View File

@ -33,15 +33,6 @@ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
return rng; 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 } // namespace range
using range::generate; using range::generate;
} // namespace boost } // namespace boost

73
include/boost/range/algorithm/heap_algorithm.hpp
View File

@ -27,18 +27,10 @@ namespace boost
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept /// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange> template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng) inline RandomAccessRange& push_heap(RandomAccessRange& rng)
{ {
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng)); std::push_heap(boost::begin(rng), boost::end(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; return rng;
} }
@ -51,15 +43,6 @@ inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
return rng; 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 /// \brief template function pop_heap
/// ///
/// range-based version of the pop_heap std algorithm /// range-based version of the pop_heap std algorithm
@ -74,15 +57,6 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng)
return 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 /// \overload
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred) inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
@ -92,15 +66,6 @@ inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
return rng; 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 /// \brief template function make_heap
/// ///
/// range-based version of the make_heap std algorithm /// range-based version of the make_heap std algorithm
@ -115,15 +80,6 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng)
return rng; return rng;
} }
/// \overload
template<class RandomAccessRange>
inline 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 /// \overload
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred) inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
@ -133,15 +89,6 @@ inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
return rng; 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 /// \brief template function sort_heap
/// ///
/// range-based version of the sort_heap std algorithm /// range-based version of the sort_heap std algorithm
@ -156,15 +103,6 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng)
return 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 /// \overload
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred) inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
@ -174,15 +112,6 @@ inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
return rng; 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 } // namespace range
using range::push_heap; using range::push_heap;
using range::pop_heap; using range::pop_heap;

21
include/boost/range/algorithm/inplace_merge.hpp
View File

@ -35,16 +35,6 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
return rng; return rng;
} }
/// \overload
template<class BidirectionalRange>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng;
}
/// \overload /// \overload
template<class BidirectionalRange, class BinaryPredicate> template<class BidirectionalRange, class BinaryPredicate>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
@ -56,17 +46,6 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
return rng; return rng;
} }
/// \overload
template<class BidirectionalRange, class BinaryPredicate>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
} // namespace range } // namespace range
using range::inplace_merge; using range::inplace_merge;
} // namespace boost } // namespace boost

40
include/boost/range/algorithm/max_element.hpp
View File

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

40
include/boost/range/algorithm/min_element.hpp
View File

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

91
include/boost/range/algorithm/mismatch.hpp
View File

@ -69,36 +69,6 @@ namespace boost
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange1, class SinglePassRange2 > template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair< inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
@ -112,52 +82,6 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
::boost::begin(rng2), ::boost::end(rng2)); ::boost::begin(rng2), ::boost::end(rng2));
} }
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
/// \overload /// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair< inline std::pair<
@ -173,21 +97,6 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
::boost::begin(rng2), ::boost::end(rng2), pred); ::boost::begin(rng2), ::boost::end(rng2), pred);
} }
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
} // namespace range } // namespace range
using range::mismatch; using range::mismatch;
} // namespace boost } // namespace boost

21
include/boost/range/algorithm/nth_element.hpp
View File

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

21
include/boost/range/algorithm/partial_sort.hpp
View File

@ -35,16 +35,6 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
return 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 /// \overload
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& partial_sort(RandomAccessRange& rng, inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
@ -57,17 +47,6 @@ inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
return 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 } // namespace range
using range::partial_sort; using range::partial_sort;
} // namespace boost } // namespace boost

16
include/boost/range/algorithm/partial_sort_copy.hpp
View File

@ -28,30 +28,24 @@ namespace boost
/// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept /// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<typename SinglePassRange, typename RandomAccessRange> template<class SinglePassRange, class RandomAccessRange>
inline typename range_iterator<RandomAccessRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2) partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
{ {
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)); boost::begin(rng2), boost::end(rng2));
} }
/// \overload /// \overload
template<typename SinglePassRange, typename RandomAccessRange, template<class SinglePassRange, class RandomAccessRange,
typename BinaryPredicate> class BinaryPredicate>
inline typename range_iterator<RandomAccessRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2, partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred); boost::begin(rng2), boost::end(rng2), pred);

20
include/boost/range/algorithm/partition.hpp
View File

@ -34,15 +34,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
return std::partition(boost::begin(rng),boost::end(rng),pred); return std::partition(boost::begin(rng),boost::end(rng),pred);
} }
/// \overload
template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const 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 // range_return overloads
/// \overload /// \overload
@ -56,17 +47,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); 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 } // namespace range
using range::partition; using range::partition;
} // namespace boost } // namespace boost

36
include/boost/range/algorithm/permutation.hpp
View File

@ -33,14 +33,6 @@ inline bool next_permutation(BidirectionalRange& rng)
return std::next_permutation(boost::begin(rng), boost::end(rng)); return std::next_permutation(boost::begin(rng), boost::end(rng));
} }
/// \overload
template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload /// \overload
template<class BidirectionalRange, class Compare> template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
@ -50,16 +42,6 @@ inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
comp_pred); comp_pred);
} }
/// \overload
template<class BidirectionalRange, class Compare>
inline bool next_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \brief template function prev_permutation /// \brief template function prev_permutation
/// ///
/// range-based version of the prev_permutation std algorithm /// range-based version of the prev_permutation std algorithm
@ -73,14 +55,6 @@ inline bool prev_permutation(BidirectionalRange& rng)
return std::prev_permutation(boost::begin(rng), boost::end(rng)); return std::prev_permutation(boost::begin(rng), boost::end(rng));
} }
/// \overload
template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload /// \overload
template<class BidirectionalRange, class Compare> template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
@ -90,16 +64,6 @@ inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
comp_pred); comp_pred);
} }
/// \overload
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
} // namespace range } // namespace range
using range::next_permutation; using range::next_permutation;
using range::prev_permutation; using range::prev_permutation;

18
include/boost/range/algorithm/random_shuffle.hpp
View File

@ -34,15 +34,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
return 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 /// \overload
template<class RandomAccessRange, class Generator> template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen) inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
@ -52,15 +43,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
return rng; 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 } // namespace range
using range::random_shuffle; using range::random_shuffle;
} // namespace boost } // namespace boost

20
include/boost/range/algorithm/remove.hpp
View File

@ -34,15 +34,6 @@ remove(ForwardRange& rng, const Value& val)
return std::remove(boost::begin(rng),boost::end(rng),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 // range_return overloads
/// \overload /// \overload
@ -56,17 +47,6 @@ remove(ForwardRange& rng, const Value& val)
rng); 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 } // namespace range
using range::remove; using range::remove;
} // namespace boost } // namespace boost

20
include/boost/range/algorithm/remove_if.hpp
View File

@ -35,15 +35,6 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
return std::remove_if(boost::begin(rng), boost::end(rng), 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 // range_return overloads
/// \overload /// \overload
@ -57,17 +48,6 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
rng); 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 } // namespace range
using range::remove_if; using range::remove_if;
} // namespace boost } // namespace boost

11
include/boost/range/algorithm/replace.hpp
View File

@ -35,17 +35,6 @@ replace(ForwardRange& rng, const Value& what,
return rng; 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 } // namespace range
using range::replace; using range::replace;
} // namespace boost; } // namespace boost;

11
include/boost/range/algorithm/replace_if.hpp
View File

@ -36,17 +36,6 @@ inline ForwardRange&
return rng; 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 } // namespace range
using range::replace_if; using range::replace_if;
} // namespace boost } // namespace boost

9
include/boost/range/algorithm/reverse.hpp
View File

@ -34,15 +34,6 @@ inline BidirectionalRange& reverse(BidirectionalRange& rng)
return 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 } // namespace range
using range::reverse; using range::reverse;
} // namespace boost } // namespace boost

10
include/boost/range/algorithm/reverse_copy.hpp
View File

@ -26,15 +26,7 @@ namespace boost
/// range-based version of the reverse_copy std algorithm /// range-based version of the reverse_copy std algorithm
/// ///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
template<typename BidirectionalRange, typename OutputIterator> template<class BidirectionalRange, class OutputIterator>
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
{
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}
/// \overload
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out) inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
{ {
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));

15
include/boost/range/algorithm/rotate.hpp
View File

@ -25,26 +25,15 @@ namespace boost
/// range-based version of the rotate std algorithm /// range-based version of the rotate std algorithm
/// ///
/// \pre Rng meets the requirements for a Forward range /// \pre Rng meets the requirements for a Forward range
template<typename ForwardRange> template<class ForwardRange>
inline ForwardRange& rotate(ForwardRange& rng, inline ForwardRange& rotate(ForwardRange& rng,
typename range_iterator<ForwardRange>::type middle) BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type middle)
{ {
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng)); std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng; return rng;
} }
/// \overload
template<typename ForwardRange>
inline const ForwardRange&
rotate(const ForwardRange& rng,
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 } // namespace range
using range::rotate; using range::rotate;
} // namespace boost } // namespace boost

6
include/boost/range/algorithm/rotate_copy.hpp
View File

@ -28,9 +28,9 @@ namespace boost
/// \pre Rng meets the requirements for a Forward range /// \pre Rng meets the requirements for a Forward range
template<typename ForwardRange, typename OutputIterator> template<typename ForwardRange, typename OutputIterator>
inline OutputIterator rotate_copy( inline OutputIterator rotate_copy(
const ForwardRange& rng, const ForwardRange& rng,
typename range_iterator<const ForwardRange>::type middle, BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle,
OutputIterator target OutputIterator target
) )
{ {
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));

51
include/boost/range/algorithm/search.hpp
View File

@ -38,17 +38,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2)
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
} }
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload /// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
@ -60,18 +49,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
boost::begin(rng2),boost::end(rng2),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
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
// range_return overloads // range_return overloads
/// \overload /// \overload
@ -87,19 +64,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2)
rng1); rng1);
} }
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(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::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)),
rng1);
}
/// \overload /// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2, template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate > class BinaryPredicate >
@ -114,21 +78,6 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
rng1); rng1);
} }
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(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::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred),
rng1);
}
} // namespace range } // namespace range
using range::search; using range::search;
} // namespace boost } // namespace boost

80
include/boost/range/algorithm/search_n.hpp
View File

@ -31,8 +31,8 @@ namespace boost
/// \pre Value is a model of the EqualityComparableConcept /// \pre Value is a model of the EqualityComparableConcept
/// \pre ForwardRange's value type is a model of the EqualityComparableConcept /// \pre ForwardRange's value type is a model of the EqualityComparableConcept
/// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value /// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
template< typename ForwardRange, typename Integer, typename Value > template< class ForwardRange, class Integer, class Value >
inline typename range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value) search_n(ForwardRange& rng, Integer count, const Value& value)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@ -40,38 +40,13 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
} }
/// \overload /// \overload
template< typename ForwardRange, typename Integer, typename Value > template< class ForwardRange, class Integer, class Value,
inline typename range_iterator<const ForwardRange>::type class BinaryPredicate >
search_n(const ForwardRange& rng, Integer count, const Value& value) inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::search_n(boost::begin(rng), boost::end(rng), count, value);
}
/// \overload
template< typename ForwardRange, typename Integer, class Value,
typename BinaryPredicate >
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value, search_n(ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate binary_pred) BinaryPredicate binary_pred)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type, const Value&>));
return std::search_n(boost::begin(rng), boost::end(rng),
count, value, binary_pred);
}
/// \overload
template< typename ForwardRange, typename Integer, typename Value,
typename BinaryPredicate >
inline 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((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type, const Value&>));
return std::search_n(boost::begin(rng), boost::end(rng), return std::search_n(boost::begin(rng), boost::end(rng),
count, value, binary_pred); count, value, binary_pred);
} }
@ -79,9 +54,9 @@ search_n(const ForwardRange& rng, Integer count, const Value& value,
// range_return overloads // range_return overloads
/// \overload /// \overload
template< range_return_value re, typename ForwardRange, typename Integer, template< range_return_value re, class ForwardRange, class Integer,
typename Value > class Value >
inline typename range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value) search_n(ForwardRange& rng, Integer count, const Value& value)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@ -92,52 +67,19 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
} }
/// \overload /// \overload
template< range_return_value re, typename ForwardRange, typename Integer, template< range_return_value re, class ForwardRange, class Integer,
class Value > class Value, class BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value),
rng);
}
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
typename Value, typename BinaryPredicate >
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value, search_n(ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate pred) BinaryPredicate pred)
{ {
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
const Value&>));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng), pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value, pred), count, value, pred),
rng); rng);
} }
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
typename Value, typename BinaryPredicate >
inline 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((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type,
const Value&>));
return range_return<const ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value, pred),
rng);
}
} // namespace range } // namespace range
using range::search_n; using range::search_n;
} // namespace boost } // namespace boost

18
include/boost/range/algorithm/sort.hpp
View File

@ -34,15 +34,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng)
return 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 /// \overload
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred) inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
@ -52,15 +43,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
return rng; 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 } // namespace range
using range::sort; using range::sort;
} // namespace boost } // namespace boost

20
include/boost/range/algorithm/stable_partition.hpp
View File

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

18
include/boost/range/algorithm/stable_sort.hpp
View File

@ -34,15 +34,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
return 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 /// \overload
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred) inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
@ -52,15 +43,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate so
return rng; 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 } // namespace range
using range::stable_sort; using range::stable_sort;
} // namespace boost } // namespace boost

12
include/boost/range/algorithm/swap_ranges.hpp
View File

@ -22,7 +22,7 @@ namespace boost
{ {
namespace range_detail namespace range_detail
{ {
template<typename Iterator1, typename Iterator2> template<class Iterator1, class Iterator2>
void swap_ranges_impl(Iterator1 it1, Iterator1 last1, void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
Iterator2 it2, Iterator2 last2, Iterator2 it2, Iterator2 last2,
single_pass_traversal_tag, single_pass_traversal_tag,
@ -36,7 +36,7 @@ namespace boost
} }
} }
template<typename Iterator1, typename Iterator2> template<class Iterator1, class Iterator2>
void swap_ranges_impl(Iterator1 it1, Iterator1 last1, void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
Iterator2 it2, Iterator2 last2, Iterator2 it2, Iterator2 last2,
random_access_traversal_tag, random_access_traversal_tag,
@ -47,13 +47,13 @@ namespace boost
std::swap_ranges(it1, last1, it2); std::swap_ranges(it1, last1, it2);
} }
template<typename Iterator1, typename Iterator2> template<class Iterator1, class Iterator2>
void swap_ranges_impl(Iterator1 first1, Iterator1 last1, void swap_ranges_impl(Iterator1 first1, Iterator1 last1,
Iterator2 first2, Iterator2 last2) Iterator2 first2, Iterator2 last2)
{ {
swap_ranges_impl(first1, last1, first2, last2, swap_ranges_impl(first1, last1, first2, last2,
typename iterator_traversal<Iterator1>::type(), BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator1>::type(),
typename iterator_traversal<Iterator2>::type()); BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator2>::type());
} }
} // namespace range_detail } // namespace range_detail
@ -66,7 +66,7 @@ namespace boost
/// ///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
template< typename SinglePassRange1, typename SinglePassRange2 > template< class SinglePassRange1, class SinglePassRange2 >
inline SinglePassRange2& inline SinglePassRange2&
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2) swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
{ {

36
include/boost/range/algorithm/unique.hpp
View File

@ -36,16 +36,6 @@ unique( ForwardRange& rng )
boost::end(rng)), rng ); boost::end(rng)), rng );
} }
/// \overload
template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
}
/// \overload /// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate > template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
@ -56,16 +46,6 @@ unique( ForwardRange& rng, BinaryPredicate pred )
pack(std::unique(boost::begin(rng), boost::end(rng), pred), pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng); rng);
} }
/// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload /// \overload
template< class ForwardRange > template< class ForwardRange >
@ -76,14 +56,6 @@ unique( ForwardRange& rng )
return ::boost::range::unique<return_begin_found>(rng); return ::boost::range::unique<return_begin_found>(rng);
} }
/// \overload /// \overload
template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
unique( const ForwardRange& rng )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange, class BinaryPredicate > template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred ) unique( ForwardRange& rng, BinaryPredicate pred )
@ -91,14 +63,6 @@ unique( ForwardRange& rng, BinaryPredicate pred )
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng); return ::boost::range::unique<return_begin_found>(rng);
} }
/// \overload
template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng, pred);
}
} // namespace range } // namespace range
using range::unique; using range::unique;