|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r61495 - in trunk/boost/range: adaptor algorithm
From: neil_at_[hidden]
Date: 2010-04-22 18:43:59
Author: neilgroves
Date: 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
New Revision: 61495
URL: http://svn.boost.org/trac/boost/changeset/61495
Log:
Boost.Range brought back some of the const overloads that were over-zealously removed.
Text files modified:
trunk/boost/range/adaptor/sliced.hpp | 47 ++++++++++++++------
trunk/boost/range/algorithm/adjacent_find.hpp | 65 +++++++++++++++++++++++++---
trunk/boost/range/algorithm/count.hpp | 9 +++
trunk/boost/range/algorithm/count_if.hpp | 9 +++
trunk/boost/range/algorithm/equal_range.hpp | 24 ++++++++++
trunk/boost/range/algorithm/for_each.hpp | 8 +++
trunk/boost/range/algorithm/inplace_merge.hpp | 21 +++++++++
trunk/boost/range/algorithm/max_element.hpp | 40 +++++++++++++++++
trunk/boost/range/algorithm/min_element.hpp | 40 +++++++++++++++++
trunk/boost/range/algorithm/mismatch.hpp | 91 ++++++++++++++++++++++++++++++++++++++++
trunk/boost/range/algorithm/nth_element.hpp | 21 +++++++++
trunk/boost/range/algorithm/permutation.hpp | 36 +++++++++++++++
trunk/boost/range/algorithm/search.hpp | 49 +++++++++++++++++++++
trunk/boost/range/algorithm/search_n.hpp | 58 +++++++++++++++++++++++++
trunk/boost/range/algorithm/stable_partition.hpp | 20 ++++++++
trunk/boost/range/algorithm/unique.hpp | 36 +++++++++++++++
16 files changed, 552 insertions(+), 22 deletions(-)
Modified: trunk/boost/range/adaptor/sliced.hpp
==============================================================================
--- trunk/boost/range/adaptor/sliced.hpp (original)
+++ trunk/boost/range/adaptor/sliced.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -27,24 +27,43 @@
std::size_t u;
};
- template< class RandomAccessRange >
- inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
- slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
- {
- BOOST_ASSERT( t <= u && "error in slice indices" );
+ template< class RandomAccessRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+ slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
+ {
+ BOOST_ASSERT( t <= u && "error in slice indices" );
BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
- "second slice index out of bounds" );
+ "second slice index out of bounds" );
+
+ return boost::make_iterator_range( rng, t, u - boost::size(rng) );
+ }
+
+ template< class RandomAccessRange >
+ inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type >
+ slice( const RandomAccessRange& rng, std::size_t t, std::size_t u )
+ {
+ BOOST_ASSERT( t <= u && "error in slice indices" );
+ BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
+ "second slice index out of bounds" );
return boost::make_iterator_range( rng, t, u - boost::size(rng) );
- }
+ }
+
+ template< class RandomAccessRange >
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
+ operator|( RandomAccessRange& r, const sliced& f )
+ {
+ return adaptors::slice( r, f.t, f.u );
+ }
- template< class RandomAccessRange >
- inline iterator_range<
- BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type >
- operator|( RandomAccessRange& r, const sliced& f )
- {
- return adaptors::slice( r, f.t, f.u );
- }
+ template< class RandomAccessRange >
+ inline iterator_range<
+ BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type >
+ operator|( const RandomAccessRange& r, const sliced& f )
+ {
+ return adaptors::slice( r, f.t, f.u );
+ }
} // namespace adaptors
} // namespace boost
Modified: trunk/boost/range/algorithm/adjacent_find.hpp
==============================================================================
--- trunk/boost/range/algorithm/adjacent_find.hpp (original)
+++ trunk/boost/range/algorithm/adjacent_find.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -28,8 +28,8 @@
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
-template< class ForwardRange >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+template< typename ForwardRange >
+inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -37,19 +37,43 @@
}
/// \overload
-template< class ForwardRange, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
+template< typename ForwardRange >
+inline typename range_iterator<const 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)
{
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);
}
// range_return overloads
/// \overload
-template< range_return_value re, class ForwardRange >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+template< range_return_value re, typename ForwardRange >
+inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
@@ -59,16 +83,41 @@
}
/// \overload
-template< range_return_value re, class ForwardRange, class BinaryPredicate >
-inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
+template< range_return_value re, typename ForwardRange >
+inline typename range_return<const 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)
{
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>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
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
using range::adjacent_find;
} // namespace boost
Modified: trunk/boost/range/algorithm/count.hpp
==============================================================================
--- trunk/boost/range/algorithm/count.hpp (original)
+++ trunk/boost/range/algorithm/count.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -27,6 +27,15 @@
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
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
count(const SinglePassRange& rng, const Value& val)
{
Modified: trunk/boost/range/algorithm/count_if.hpp
==============================================================================
--- trunk/boost/range/algorithm/count_if.hpp (original)
+++ trunk/boost/range/algorithm/count_if.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -28,6 +28,15 @@
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate >
+inline BOOST_DEDUCED_TYPENAME 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
count_if(const SinglePassRange& rng, UnaryPredicate pred)
{
Modified: trunk/boost/range/algorithm/equal_range.hpp
==============================================================================
--- trunk/boost/range/algorithm/equal_range.hpp (original)
+++ trunk/boost/range/algorithm/equal_range.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -38,6 +38,18 @@
}
/// \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
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
@@ -49,6 +61,18 @@
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
using range::equal_range;
} // namespace boost
Modified: trunk/boost/range/algorithm/for_each.hpp
==============================================================================
--- trunk/boost/range/algorithm/for_each.hpp (original)
+++ trunk/boost/range/algorithm/for_each.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -33,6 +33,14 @@
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
using range::for_each;
} // namespace boost
Modified: trunk/boost/range/algorithm/inplace_merge.hpp
==============================================================================
--- trunk/boost/range/algorithm/inplace_merge.hpp (original)
+++ trunk/boost/range/algorithm/inplace_merge.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -36,6 +36,16 @@
}
/// \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
template<class BidirectionalRange, class BinaryPredicate>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
@@ -46,6 +56,17 @@
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
using range::inplace_merge;
} // namespace boost
Modified: trunk/boost/range/algorithm/max_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/max_element.hpp (original)
+++ trunk/boost/range/algorithm/max_element.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -36,6 +36,15 @@
}
/// \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
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
@@ -44,6 +53,15 @@
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
/// \overload
@@ -58,6 +76,17 @@
}
/// \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
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
@@ -68,6 +97,17 @@
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
using range::max_element;
} // namespace boost
Modified: trunk/boost/range/algorithm/min_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/min_element.hpp (original)
+++ trunk/boost/range/algorithm/min_element.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -36,6 +36,15 @@
}
/// \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
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
@@ -44,6 +53,15 @@
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
/// \overload
@@ -58,6 +76,17 @@
}
/// \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
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
@@ -68,6 +97,17 @@
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
using range::min_element;
} // namespace boost
Modified: trunk/boost/range/algorithm/mismatch.hpp
==============================================================================
--- trunk/boost/range/algorithm/mismatch.hpp (original)
+++ trunk/boost/range/algorithm/mismatch.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -71,6 +71,36 @@
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<
+ BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{
@@ -83,6 +113,52 @@
}
/// \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
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
@@ -97,6 +173,21 @@
::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
using range::mismatch;
} // namespace boost
Modified: trunk/boost/range/algorithm/nth_element.hpp
==============================================================================
--- trunk/boost/range/algorithm/nth_element.hpp (original)
+++ trunk/boost/range/algorithm/nth_element.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -36,6 +36,16 @@
}
/// \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
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
@@ -46,6 +56,17 @@
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
using range::nth_element;
} // namespace boost
Modified: trunk/boost/range/algorithm/permutation.hpp
==============================================================================
--- trunk/boost/range/algorithm/permutation.hpp (original)
+++ trunk/boost/range/algorithm/permutation.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -34,6 +34,14 @@
}
/// \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
template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{
@@ -42,6 +50,16 @@
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
///
/// range-based version of the prev_permutation std algorithm
@@ -56,6 +74,14 @@
}
/// \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
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{
@@ -64,6 +90,16 @@
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
using range::next_permutation;
using range::prev_permutation;
Modified: trunk/boost/range/algorithm/search.hpp
==============================================================================
--- trunk/boost/range/algorithm/search.hpp (original)
+++ trunk/boost/range/algorithm/search.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -39,6 +39,17 @@
}
/// \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
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
@@ -49,6 +60,17 @@
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
/// \overload
@@ -65,6 +87,19 @@
}
/// \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
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
@@ -78,6 +113,20 @@
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
using range::search;
} // namespace boost
Modified: trunk/boost/range/algorithm/search_n.hpp
==============================================================================
--- trunk/boost/range/algorithm/search_n.hpp (original)
+++ trunk/boost/range/algorithm/search_n.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -40,6 +40,15 @@
}
/// \overload
+template< class ForwardRange, class Integer, class Value >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ return std::search_n(boost::begin(rng), boost::end(rng), count, value);
+}
+
+/// \overload
template< class ForwardRange, class Integer, class Value,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
@@ -47,6 +56,22 @@
BinaryPredicate binary_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type, const Value&>));
+ return std::search_n(boost::begin(rng), boost::end(rng),
+ count, value, binary_pred);
+}
+
+/// \overload
+template< class ForwardRange, class Integer, class Value,
+ class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate binary_pred)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type, const Value&>));
return std::search_n(boost::begin(rng), boost::end(rng),
count, value, binary_pred);
}
@@ -68,18 +93,51 @@
/// \overload
template< range_return_value re, class ForwardRange, class Integer,
+ class Value >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ 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, class ForwardRange, class Integer,
class Value, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type,
+ const Value&>));
return range_return<ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value, pred),
rng);
}
+/// \overload
+template< range_return_value re, class ForwardRange, class Integer,
+ class Value, class BinaryPredicate >
+inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
+search_n(const ForwardRange& rng, Integer count, const Value& value,
+ BinaryPredicate pred)
+{
+ BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
+ BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+ BOOST_DEDUCED_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
using range::search_n;
} // namespace boost
Modified: trunk/boost/range/algorithm/stable_partition.hpp
==============================================================================
--- trunk/boost/range/algorithm/stable_partition.hpp (original)
+++ trunk/boost/range/algorithm/stable_partition.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -35,6 +35,15 @@
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
template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
@@ -46,6 +55,17 @@
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
using range::stable_partition;
} // namespace boost
Modified: trunk/boost/range/algorithm/unique.hpp
==============================================================================
--- trunk/boost/range/algorithm/unique.hpp (original)
+++ trunk/boost/range/algorithm/unique.hpp 2010-04-22 18:43:57 EDT (Thu, 22 Apr 2010)
@@ -37,6 +37,16 @@
}
/// \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
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng, BinaryPredicate pred )
@@ -46,6 +56,16 @@
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
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
template< class ForwardRange >
@@ -56,6 +76,14 @@
return ::boost::range::unique<return_begin_found>(rng);
}
/// \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 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred )
@@ -63,6 +91,14 @@
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
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
using range::unique;
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk