From adc4b5db3b493d29cbf943f9510d41c27d342888 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Thu, 22 Apr 2010 22:43:57 +0000 Subject: [PATCH] Boost.Range brought back some of the const overloads that were over-zealously removed. [SVN r61495] --- include/boost/range/adaptor/sliced.hpp | 47 +++++++--- .../boost/range/algorithm/adjacent_find.hpp | 65 +++++++++++-- include/boost/range/algorithm/count.hpp | 9 ++ include/boost/range/algorithm/count_if.hpp | 9 ++ include/boost/range/algorithm/equal_range.hpp | 24 +++++ include/boost/range/algorithm/for_each.hpp | 8 ++ .../boost/range/algorithm/inplace_merge.hpp | 21 +++++ include/boost/range/algorithm/max_element.hpp | 40 ++++++++ include/boost/range/algorithm/min_element.hpp | 40 ++++++++ include/boost/range/algorithm/mismatch.hpp | 91 +++++++++++++++++++ include/boost/range/algorithm/nth_element.hpp | 21 +++++ include/boost/range/algorithm/permutation.hpp | 36 ++++++++ include/boost/range/algorithm/search.hpp | 49 ++++++++++ include/boost/range/algorithm/search_n.hpp | 58 ++++++++++++ .../range/algorithm/stable_partition.hpp | 20 ++++ include/boost/range/algorithm/unique.hpp | 36 ++++++++ 16 files changed, 552 insertions(+), 22 deletions(-) diff --git a/include/boost/range/adaptor/sliced.hpp b/include/boost/range/adaptor/sliced.hpp index e5084d6..eb506e0 100755 --- a/include/boost/range/adaptor/sliced.hpp +++ b/include/boost/range/adaptor/sliced.hpp @@ -27,24 +27,43 @@ namespace boost std::size_t u; }; - template< class RandomAccessRange > - inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator::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::type > + slice( RandomAccessRange& rng, std::size_t t, std::size_t u ) + { + BOOST_ASSERT( t <= u && "error in slice indices" ); BOOST_ASSERT( static_cast(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::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(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::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::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::type > + operator|( const RandomAccessRange& r, const sliced& f ) + { + return adaptors::slice( r, f.t, f.u ); + } } // namespace adaptors } // namespace boost diff --git a/include/boost/range/algorithm/adjacent_find.hpp b/include/boost/range/algorithm/adjacent_find.hpp index 6ff4ad6..1b88dae 100755 --- a/include/boost/range/algorithm/adjacent_find.hpp +++ b/include/boost/range/algorithm/adjacent_find.hpp @@ -28,8 +28,8 @@ namespace boost /// /// \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::type +template< typename ForwardRange > +inline typename range_iterator::type adjacent_find(ForwardRange & rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); @@ -37,19 +37,43 @@ adjacent_find(ForwardRange & rng) } /// \overload -template< class ForwardRange, class BinaryPredicate > -inline BOOST_DEDUCED_TYPENAME range_iterator::type +template< typename ForwardRange > +inline typename range_iterator::type +adjacent_find(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + return std::adjacent_find(boost::begin(rng),boost::end(rng)); +} + +/// \overload +template< typename ForwardRange, typename BinaryPredicate > +inline typename range_iterator::type adjacent_find(ForwardRange & rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, + typename range_value::type>)); + return std::adjacent_find(boost::begin(rng),boost::end(rng),pred); +} + +/// \overload +template< typename ForwardRange, typename BinaryPredicate > +inline typename range_iterator::type +adjacent_find(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, + typename range_value::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::type +template< range_return_value re, typename ForwardRange > +inline typename range_return::type adjacent_find(ForwardRange & rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); @@ -59,16 +83,41 @@ adjacent_find(ForwardRange & rng) } /// \overload -template< range_return_value re, class ForwardRange, class BinaryPredicate > -inline BOOST_DEDUCED_TYPENAME range_return::type +template< range_return_value re, typename ForwardRange > +inline typename range_return::type +adjacent_find(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + return range_return:: + 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::type adjacent_find(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, + typename range_value::type>)); return range_return:: 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::type +adjacent_find(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + return range_return:: + pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), + rng); +} + } // namespace range using range::adjacent_find; } // namespace boost diff --git a/include/boost/range/algorithm/count.hpp b/include/boost/range/algorithm/count.hpp index 3174dc0..8316ce0 100755 --- a/include/boost/range/algorithm/count.hpp +++ b/include/boost/range/algorithm/count.hpp @@ -27,6 +27,15 @@ namespace boost /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept template< class SinglePassRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_difference::type +count(SinglePassRange& rng, const Value& val) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::count(boost::begin(rng), boost::end(rng), val); +} + +/// \overload +template< class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME range_difference::type count(const SinglePassRange& rng, const Value& val) { diff --git a/include/boost/range/algorithm/count_if.hpp b/include/boost/range/algorithm/count_if.hpp index b101226..ae17b0e 100755 --- a/include/boost/range/algorithm/count_if.hpp +++ b/include/boost/range/algorithm/count_if.hpp @@ -28,6 +28,15 @@ namespace boost /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template< class SinglePassRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME boost::range_difference::type +count_if(SinglePassRange& rng, UnaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::count_if(boost::begin(rng), boost::end(rng), pred); +} + +/// \overload +template< class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME boost::range_difference::type count_if(const SinglePassRange& rng, UnaryPredicate pred) { diff --git a/include/boost/range/algorithm/equal_range.hpp b/include/boost/range/algorithm/equal_range.hpp index cc3c510..4aa4a54 100755 --- a/include/boost/range/algorithm/equal_range.hpp +++ b/include/boost/range/algorithm/equal_range.hpp @@ -37,6 +37,18 @@ equal_range(ForwardRange& rng, const Value& val) return std::equal_range(boost::begin(rng), boost::end(rng), val); } +/// \overload +template +inline std::pair< + BOOST_DEDUCED_TYPENAME boost::range_iterator::type, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type + > +equal_range(const ForwardRange& rng, const Value& val) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::equal_range(boost::begin(rng), boost::end(rng), val); +} + /// \overload template inline std::pair< @@ -49,6 +61,18 @@ equal_range(ForwardRange& rng, const Value& val, SortPredicate pred) return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); } +/// \overload +template +inline std::pair< + BOOST_DEDUCED_TYPENAME boost::range_iterator::type, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type + > +equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); +} + } // namespace range using range::equal_range; } // namespace boost diff --git a/include/boost/range/algorithm/for_each.hpp b/include/boost/range/algorithm/for_each.hpp index f258815..714a06f 100755 --- a/include/boost/range/algorithm/for_each.hpp +++ b/include/boost/range/algorithm/for_each.hpp @@ -33,6 +33,14 @@ inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction 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 )); + return std::for_each(boost::begin(rng), boost::end(rng), fun); +} + } // namespace range using range::for_each; } // namespace boost diff --git a/include/boost/range/algorithm/inplace_merge.hpp b/include/boost/range/algorithm/inplace_merge.hpp index 80c13f4..dfadbaa 100755 --- a/include/boost/range/algorithm/inplace_merge.hpp +++ b/include/boost/range/algorithm/inplace_merge.hpp @@ -35,6 +35,16 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, return rng; } +/// \overload +template +inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); + return rng; +} + /// \overload template inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, @@ -46,6 +56,17 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, return rng; } +/// \overload +template +inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle, + BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); + return rng; +} + } // namespace range using range::inplace_merge; } // namespace boost diff --git a/include/boost/range/algorithm/max_element.hpp b/include/boost/range/algorithm/max_element.hpp index d8ec692..a0c1ffd 100755 --- a/include/boost/range/algorithm/max_element.hpp +++ b/include/boost/range/algorithm/max_element.hpp @@ -35,6 +35,15 @@ max_element(ForwardRange& rng) return std::max_element(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +max_element(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::max_element(boost::begin(rng), boost::end(rng)); +} + /// \overload template inline BOOST_DEDUCED_TYPENAME range_iterator::type @@ -44,6 +53,15 @@ max_element(ForwardRange& rng, BinaryPredicate pred) return std::max_element(boost::begin(rng), boost::end(rng), pred); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +max_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::max_element(boost::begin(rng), boost::end(rng), pred); +} + // range_return overloads /// \overload @@ -57,6 +75,17 @@ max_element(ForwardRange& rng) rng); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +max_element(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::max_element(boost::begin(rng), boost::end(rng)), + rng); +} + /// \overload template inline BOOST_DEDUCED_TYPENAME range_return::type @@ -68,6 +97,17 @@ max_element(ForwardRange& rng, BinaryPredicate pred) rng); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +max_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::max_element(boost::begin(rng), boost::end(rng), pred), + rng); +} + } // namespace range using range::max_element; } // namespace boost diff --git a/include/boost/range/algorithm/min_element.hpp b/include/boost/range/algorithm/min_element.hpp index 3bc02da..c966b1e 100755 --- a/include/boost/range/algorithm/min_element.hpp +++ b/include/boost/range/algorithm/min_element.hpp @@ -35,6 +35,15 @@ min_element(ForwardRange& rng) return std::min_element(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +min_element(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::min_element(boost::begin(rng), boost::end(rng)); +} + /// \overload template inline BOOST_DEDUCED_TYPENAME range_iterator::type @@ -44,6 +53,15 @@ min_element(ForwardRange& rng, BinaryPredicate pred) return std::min_element(boost::begin(rng), boost::end(rng), pred); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +min_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::min_element(boost::begin(rng), boost::end(rng), pred); +} + // range_return overloads /// \overload @@ -57,6 +75,17 @@ min_element(ForwardRange& rng) rng); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +min_element(const ForwardRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::min_element(boost::begin(rng), boost::end(rng)), + rng); +} + /// \overload template inline BOOST_DEDUCED_TYPENAME range_return::type @@ -68,6 +97,17 @@ min_element(ForwardRange& rng, BinaryPredicate pred) rng); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +min_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::min_element(boost::begin(rng), boost::end(rng), pred), + rng); +} + } // namespace range using range::min_element; } // namespace boost diff --git a/include/boost/range/algorithm/mismatch.hpp b/include/boost/range/algorithm/mismatch.hpp index c0cde9b..2819c33 100755 --- a/include/boost/range/algorithm/mismatch.hpp +++ b/include/boost/range/algorithm/mismatch.hpp @@ -69,6 +69,36 @@ namespace boost /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class SinglePassRange1, class SinglePassRange2 > +inline std::pair< + BOOST_DEDUCED_TYPENAME range_iterator::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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::type, BOOST_DEDUCED_TYPENAME range_iterator::type > @@ -82,6 +112,52 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2) ::boost::begin(rng2), ::boost::end(rng2)); } +/// \overload +template< class SinglePassRange1, class SinglePassRange2 > +inline std::pair< + BOOST_DEDUCED_TYPENAME range_iterator::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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< @@ -97,6 +173,21 @@ mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) ::boost::begin(rng2), ::boost::end(rng2), pred); } +/// \overload +template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > +inline std::pair< + BOOST_DEDUCED_TYPENAME range_iterator::type, + BOOST_DEDUCED_TYPENAME range_iterator::type > +mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + 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 diff --git a/include/boost/range/algorithm/nth_element.hpp b/include/boost/range/algorithm/nth_element.hpp index cf143e9..a605595 100755 --- a/include/boost/range/algorithm/nth_element.hpp +++ b/include/boost/range/algorithm/nth_element.hpp @@ -35,6 +35,16 @@ inline RandomAccessRange& nth_element(RandomAccessRange& rng, return rng; } +/// \overload +template +inline const RandomAccessRange& nth_element(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth) +{ + BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng), nth, boost::end(rng)); + return rng; +} + /// \overload template inline RandomAccessRange& nth_element(RandomAccessRange& rng, @@ -46,6 +56,17 @@ inline RandomAccessRange& nth_element(RandomAccessRange& rng, return rng; } +/// \overload +template +inline const RandomAccessRange& nth_element(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth, + BinaryPredicate sort_pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); + return rng; +} + } // namespace range using range::nth_element; } // namespace boost diff --git a/include/boost/range/algorithm/permutation.hpp b/include/boost/range/algorithm/permutation.hpp index 7540c96..75388cc 100755 --- a/include/boost/range/algorithm/permutation.hpp +++ b/include/boost/range/algorithm/permutation.hpp @@ -33,6 +33,14 @@ inline bool next_permutation(BidirectionalRange& rng) return std::next_permutation(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline bool next_permutation(const BidirectionalRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::next_permutation(boost::begin(rng), boost::end(rng)); +} + /// \overload template inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) @@ -42,6 +50,16 @@ inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) comp_pred); } +/// \overload +template +inline bool next_permutation(const BidirectionalRange& rng, + Compare comp_pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + 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 @@ -55,6 +73,14 @@ inline bool prev_permutation(BidirectionalRange& rng) return std::prev_permutation(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline bool prev_permutation(const BidirectionalRange& rng) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::prev_permutation(boost::begin(rng), boost::end(rng)); +} + /// \overload template inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) @@ -64,6 +90,16 @@ inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) comp_pred); } +/// \overload +template +inline bool prev_permutation(const BidirectionalRange& rng, + Compare comp_pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::prev_permutation(boost::begin(rng), boost::end(rng), + comp_pred); +} + } // namespace range using range::next_permutation; using range::prev_permutation; diff --git a/include/boost/range/algorithm/search.hpp b/include/boost/range/algorithm/search.hpp index 3f5134f..28cc6e6 100755 --- a/include/boost/range/algorithm/search.hpp +++ b/include/boost/range/algorithm/search.hpp @@ -38,6 +38,17 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2) boost::begin(rng2),boost::end(rng2)); } +/// \overload +template< class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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::type @@ -49,6 +60,17 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) boost::begin(rng2),boost::end(rng2),pred); } +/// \overload +template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::search(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred); +} + // range_return overloads /// \overload @@ -64,6 +86,19 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2) rng1); } +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + 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 > @@ -78,6 +113,20 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) rng1); } +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2, + class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::search(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred), + rng1); +} + } // namespace range using range::search; } // namespace boost diff --git a/include/boost/range/algorithm/search_n.hpp b/include/boost/range/algorithm/search_n.hpp index dfbb17a..2ced140 100755 --- a/include/boost/range/algorithm/search_n.hpp +++ b/include/boost/range/algorithm/search_n.hpp @@ -39,6 +39,15 @@ search_n(ForwardRange& rng, Integer count, const Value& value) return std::search_n(boost::begin(rng),boost::end(rng), count, value); } +/// \overload +template< class ForwardRange, class Integer, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search_n(const ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + return std::search_n(boost::begin(rng), boost::end(rng), count, value); +} + /// \overload template< class ForwardRange, class Integer, class Value, class BinaryPredicate > @@ -47,6 +56,22 @@ search_n(ForwardRange& rng, Integer count, const Value& value, BinaryPredicate binary_pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::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::type +search_n(const ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate binary_pred) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, const Value&>)); return std::search_n(boost::begin(rng), boost::end(rng), count, value, binary_pred); } @@ -66,6 +91,19 @@ search_n(ForwardRange& rng, Integer count, const Value& value) rng); } +/// \overload +template< range_return_value re, class ForwardRange, class Integer, + class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +search_n(const ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + return range_return:: + 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 > @@ -74,12 +112,32 @@ search_n(ForwardRange& rng, Integer count, const Value& value, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, + const Value&>)); return range_return:: 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::type +search_n(const ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept::type, + const Value&>)); + return range_return:: + pack(std::search_n(boost::begin(rng), boost::end(rng), + count, value, pred), + rng); +} + } // namespace range using range::search_n; } // namespace boost diff --git a/include/boost/range/algorithm/stable_partition.hpp b/include/boost/range/algorithm/stable_partition.hpp index aa003df..24febfc 100755 --- a/include/boost/range/algorithm/stable_partition.hpp +++ b/include/boost/range/algorithm/stable_partition.hpp @@ -35,6 +35,15 @@ stable_partition(BidirectionalRange& rng, UnaryPredicate pred) return std::stable_partition(boost::begin(rng), boost::end(rng), pred); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::stable_partition(boost::begin(rng),boost::end(rng),pred); +} + // range_return overloads template inline BOOST_DEDUCED_TYPENAME range_return::type @@ -46,6 +55,17 @@ stable_partition(BidirectionalRange& rng, UnaryPredicate pred) rng); } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) +{ + BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return range_return::pack( + std::stable_partition(boost::begin(rng),boost::end(rng),pred), + rng); +} + } // namespace range using range::stable_partition; } // namespace boost diff --git a/include/boost/range/algorithm/unique.hpp b/include/boost/range/algorithm/unique.hpp index b930c54..be6eaf9 100755 --- a/include/boost/range/algorithm/unique.hpp +++ b/include/boost/range/algorithm/unique.hpp @@ -36,6 +36,16 @@ unique( ForwardRange& rng ) boost::end(rng)), rng ); } +/// \overload +template< range_return_value re, class ForwardRange > +inline BOOST_DEDUCED_TYPENAME range_return::type +unique( const ForwardRange& rng ) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + 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::type @@ -46,6 +56,16 @@ unique( ForwardRange& rng, BinaryPredicate pred ) 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::type +unique( const ForwardRange& rng, BinaryPredicate pred ) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::unique(boost::begin(rng), boost::end(rng), pred), + rng); +} /// \overload template< class ForwardRange > @@ -56,6 +76,14 @@ unique( ForwardRange& rng ) return ::boost::range::unique(rng); } /// \overload +template< class ForwardRange > +inline BOOST_DEDUCED_TYPENAME range_return::type +unique( const ForwardRange& rng ) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return ::boost::range::unique(rng); +} +/// \overload template< class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return::type unique( ForwardRange& rng, BinaryPredicate pred ) @@ -63,6 +91,14 @@ unique( ForwardRange& rng, BinaryPredicate pred ) BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); return ::boost::range::unique(rng); } +/// \overload +template< class ForwardRange, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +unique( const ForwardRange& rng, BinaryPredicate pred ) +{ + BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept )); + return ::boost::range::unique(rng, pred); +} } // namespace range using range::unique;