From 22c72c53ebaa46c8fbbabae4c4005fc596a8d2c9 Mon Sep 17 00:00:00 2001 From: Neil Groves Date: Sat, 3 Apr 2010 19:14:13 +0000 Subject: [PATCH] Boost.Range algorithms are now in the boost::range namespace and brought into boost by the appropriate using statement. This allows better interoperation with Boost.Algorithm since errors only occur when the use calls similarly named ambiguous functions. In this event the user can disambiguate by using algorithm::xxx() or range::xxx(). This iteration also updates the concept assert code in the range algorithms. [SVN r61023] --- .../boost/range/algorithm/adjacent_find.hpp | 182 +++++----- .../boost/range/algorithm/binary_search.hpp | 44 ++- include/boost/range/algorithm/copy.hpp | 28 +- .../boost/range/algorithm/copy_backward.hpp | 34 +- include/boost/range/algorithm/count.hpp | 44 ++- include/boost/range/algorithm/count_if.hpp | 46 +-- include/boost/range/algorithm/equal.hpp | 66 ++-- include/boost/range/algorithm/equal_range.hpp | 106 +++--- include/boost/range/algorithm/fill.hpp | 28 +- include/boost/range/algorithm/fill_n.hpp | 30 +- include/boost/range/algorithm/find.hpp | 84 +++-- include/boost/range/algorithm/find_end.hpp | 226 ++++++------ .../boost/range/algorithm/find_first_of.hpp | 231 ++++++------ include/boost/range/algorithm/find_if.hpp | 88 ++--- include/boost/range/algorithm/for_each.hpp | 42 ++- include/boost/range/algorithm/generate.hpp | 47 +-- .../boost/range/algorithm/heap_algorithm.hpp | 299 ++++++++-------- .../boost/range/algorithm/inplace_merge.hpp | 94 ++--- .../algorithm/lexicographical_compare.hpp | 62 ++-- include/boost/range/algorithm/lower_bound.hpp | 156 ++++---- include/boost/range/algorithm/max_element.hpp | 164 +++++---- include/boost/range/algorithm/merge.hpp | 68 ++-- include/boost/range/algorithm/min_element.hpp | 164 +++++---- include/boost/range/algorithm/mismatch.hpp | 247 +++++++------ include/boost/range/algorithm/nth_element.hpp | 86 ++--- .../boost/range/algorithm/partial_sort.hpp | 88 ++--- .../range/algorithm/partial_sort_copy.hpp | 70 ++-- include/boost/range/algorithm/partition.hpp | 86 ++--- include/boost/range/algorithm/permutation.hpp | 177 +++++---- .../boost/range/algorithm/random_shuffle.hpp | 82 +++-- include/boost/range/algorithm/remove.hpp | 94 ++--- include/boost/range/algorithm/remove_copy.hpp | 36 +- include/boost/range/algorithm/remove_if.hpp | 89 ++--- include/boost/range/algorithm/replace.hpp | 52 +-- .../boost/range/algorithm/replace_copy.hpp | 32 +- .../boost/range/algorithm/replace_copy_if.hpp | 40 ++- include/boost/range/algorithm/replace_if.hpp | 55 +-- include/boost/range/algorithm/reverse.hpp | 44 ++- .../boost/range/algorithm/reverse_copy.hpp | 40 ++- include/boost/range/algorithm/rotate.hpp | 50 +-- include/boost/range/algorithm/rotate_copy.hpp | 10 +- include/boost/range/algorithm/search.hpp | 207 +++++------ include/boost/range/algorithm/search_n.hpp | 223 ++++++------ .../boost/range/algorithm/set_algorithm.hpp | 338 +++++++++--------- include/boost/range/algorithm/sort.hpp | 83 +++-- .../range/algorithm/stable_partition.hpp | 91 ++--- include/boost/range/algorithm/stable_sort.hpp | 82 +++-- include/boost/range/algorithm/swap_ranges.hpp | 38 +- include/boost/range/algorithm/transform.hpp | 84 +++-- include/boost/range/algorithm/unique.hpp | 160 +++++---- include/boost/range/algorithm/unique_copy.hpp | 50 +-- include/boost/range/algorithm/upper_bound.hpp | 160 +++++---- 52 files changed, 2766 insertions(+), 2461 deletions(-) diff --git a/include/boost/range/algorithm/adjacent_find.hpp b/include/boost/range/algorithm/adjacent_find.hpp index c84ecec..c42e5ee 100755 --- a/include/boost/range/algorithm/adjacent_find.hpp +++ b/include/boost/range/algorithm/adjacent_find.hpp @@ -19,101 +19,107 @@ namespace boost { - /// \brief template function adjacent_find - /// - /// range-based version of the adjacent_find std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< typename ForwardRange > - inline typename range_iterator::type - adjacent_find(ForwardRange & rng) + namespace range { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - return std::adjacent_find(boost::begin(rng),boost::end(rng)); - } - /// \overload - template< typename ForwardRange > - inline typename range_iterator::type - adjacent_find(const ForwardRange& rng) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - return std::adjacent_find(boost::begin(rng),boost::end(rng)); - } +/// \brief template function adjacent_find +/// +/// range-based version of the adjacent_find std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template< typename ForwardRange > +inline typename range_iterator::type +adjacent_find(ForwardRange & rng) +{ + BOOST_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_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::type, - typename range_value::type>)); - return std::adjacent_find(boost::begin(rng),boost::end(rng),pred); - } +/// \overload +template< typename ForwardRange > +inline typename range_iterator::type +adjacent_find(const ForwardRange& rng) +{ + BOOST_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(const ForwardRange& rng, BinaryPredicate pred) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_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(ForwardRange & rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_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_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_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, typename ForwardRange > - inline typename range_return::type - adjacent_find(ForwardRange & rng) - { - BOOST_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 > - inline typename range_return::type - adjacent_find(const ForwardRange& rng) - { - BOOST_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_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_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_CONCEPT_ASSERT((ForwardRangeConcept)); - return range_return:: - pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), - rng); - } +/// \overload +template< range_return_value re, typename ForwardRange > +inline typename range_return::type +adjacent_find(ForwardRange & rng) +{ + BOOST_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 > +inline typename range_return::type +adjacent_find(const ForwardRange& rng) +{ + BOOST_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_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_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_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 + #endif // include guard diff --git a/include/boost/range/algorithm/binary_search.hpp b/include/boost/range/algorithm/binary_search.hpp index 666f19c..41860a5 100755 --- a/include/boost/range/algorithm/binary_search.hpp +++ b/include/boost/range/algorithm/binary_search.hpp @@ -17,27 +17,33 @@ namespace boost { - /// \brief template function binary_search - /// - /// range-based version of the binary_search std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline bool binary_search(const ForwardRange& rng, const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::binary_search(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template - inline bool binary_search(const ForwardRange& rng, const Value& val, - BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return std::binary_search(boost::begin(rng), boost::end(rng), val, pred); - } +/// \brief template function binary_search +/// +/// range-based version of the binary_search std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline bool binary_search(const ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::binary_search(boost::begin(rng), boost::end(rng), val); } +/// \overload +template +inline bool binary_search(const ForwardRange& rng, const Value& val, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::binary_search(boost::begin(rng), boost::end(rng), val, pred); +} + + } // namespace range + using range::binary_search; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/copy.hpp b/include/boost/range/algorithm/copy.hpp index 27b88ab..b097d00 100644 --- a/include/boost/range/algorithm/copy.hpp +++ b/include/boost/range/algorithm/copy.hpp @@ -18,18 +18,24 @@ namespace boost { - /// \brief template function copy - /// - /// range-based version of the copy std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre OutputIterator is a model of the OutputIteratorConcept - template< class SinglePassRange, class OutputIterator > - inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out) + namespace range { - //BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return std::copy(boost::begin(rng),boost::end(rng),out); - } + +/// \brief template function copy +/// +/// range-based version of the copy std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre OutputIterator is a model of the OutputIteratorConcept +template< class SinglePassRange, class OutputIterator > +inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::copy(boost::begin(rng),boost::end(rng),out); } + } // namespace range + using range::copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/copy_backward.hpp b/include/boost/range/algorithm/copy_backward.hpp index 34dbebb..fddd0a8 100755 --- a/include/boost/range/algorithm/copy_backward.hpp +++ b/include/boost/range/algorithm/copy_backward.hpp @@ -17,21 +17,27 @@ namespace boost { - /// \brief template function copy_backward - /// - /// range-based version of the copy_backwards std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - /// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept - /// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept - template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator > - inline BidirectionalTraversalWriteableIterator - copy_backward(const BidirectionalRange& rng, - BidirectionalTraversalWriteableIterator out) + namespace range { - boost::function_requires< BidirectionalRangeConcept >(); - return std::copy_backward(boost::begin(rng), boost::end(rng), out); - } + +/// \brief template function copy_backward +/// +/// range-based version of the copy_backwards std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +/// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept +/// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept +template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator > +inline BidirectionalTraversalWriteableIterator +copy_backward(const BidirectionalRange& rng, + BidirectionalTraversalWriteableIterator out) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::copy_backward(boost::begin(rng), boost::end(rng), out); } + } // namespace range + using range::copy_backward; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/count.hpp b/include/boost/range/algorithm/count.hpp index e695a0c..ab4fdd1 100755 --- a/include/boost/range/algorithm/count.hpp +++ b/include/boost/range/algorithm/count.hpp @@ -18,27 +18,33 @@ namespace boost { - /// \brief template function count - /// - /// range-based version of the count std algorithm - /// - /// \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) + namespace range { - boost::function_requires< 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) - { - boost::function_requires< SinglePassRangeConcept >(); - return std::count(boost::begin(rng), boost::end(rng), val); - } +/// \brief template function count +/// +/// range-based version of the count std algorithm +/// +/// \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_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) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::count(boost::begin(rng), boost::end(rng), val); +} + + } // namespace range + using range::count; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/count_if.hpp b/include/boost/range/algorithm/count_if.hpp index 9f8b929..611312c 100755 --- a/include/boost/range/algorithm/count_if.hpp +++ b/include/boost/range/algorithm/count_if.hpp @@ -18,28 +18,34 @@ namespace boost { - /// \brief template function count_if - /// - /// range-based version of the count_if std algorithm - /// - /// \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) + namespace range { - boost::function_requires< 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) - { - boost::function_requires< SinglePassRangeConcept >(); - return std::count_if(boost::begin(rng), boost::end(rng), pred); - } +/// \brief template function count_if +/// +/// range-based version of the count_if std algorithm +/// +/// \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_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) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::count_if(boost::begin(rng), boost::end(rng), pred); +} + + } // namespace range + using range::count_if; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/equal.hpp b/include/boost/range/algorithm/equal.hpp index a7be749..e9a16fd 100755 --- a/include/boost/range/algorithm/equal.hpp +++ b/include/boost/range/algorithm/equal.hpp @@ -143,40 +143,46 @@ namespace boost return equal_impl(first1, last1, first2, last2, pred, tag1, tag2); } - - } - /// \brief template function equal - /// - /// range-based version of the equal std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< class SinglePassRange1, class SinglePassRange2 > - inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 ) + } // namespace range_detail + + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return range_detail::equal( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2) ); - } + /// \brief template function equal + /// + /// range-based version of the equal std algorithm + /// + /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept + /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept + /// \pre BinaryPredicate is a model of the BinaryPredicateConcept + template< class SinglePassRange1, class SinglePassRange2 > + inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 ) + { + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); - /// \overload - template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > - inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2, - BinaryPredicate pred ) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); + return ::boost::range_detail::equal( + ::boost::begin(rng1), ::boost::end(rng1), + ::boost::begin(rng2), ::boost::end(rng2) ); + } - return range_detail::equal( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), - pred); - } -} + /// \overload + template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > + inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2, + BinaryPredicate pred ) + { + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + + return ::boost::range_detail::equal( + ::boost::begin(rng1), ::boost::end(rng1), + ::boost::begin(rng2), ::boost::end(rng2), + pred); + } + + } // namespace range + using range::equal; +} // namespace boost #endif // include guard diff --git a/include/boost/range/algorithm/equal_range.hpp b/include/boost/range/algorithm/equal_range.hpp index 235b9db..0643701 100755 --- a/include/boost/range/algorithm/equal_range.hpp +++ b/include/boost/range/algorithm/equal_range.hpp @@ -17,58 +17,64 @@ namespace boost { - /// \brief template function equal_range - /// - /// range-based version of the equal_range std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre SortPredicate is a model of the BinaryPredicateConcept - template - inline std::pair< - BOOST_DEDUCED_TYPENAME boost::range_iterator::type, - BOOST_DEDUCED_TYPENAME boost::range_iterator::type - > - equal_range(ForwardRange& rng, const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - 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::function_requires< ForwardRangeConcept >(); - 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(ForwardRange& rng, const Value& val, SortPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - 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::function_requires< ForwardRangeConcept >(); - return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); - } +/// \brief template function equal_range +/// +/// range-based version of the equal_range std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre SortPredicate is a model of the BinaryPredicateConcept +template +inline std::pair< + BOOST_DEDUCED_TYPENAME boost::range_iterator::type, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type + > +equal_range(ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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(ForwardRange& rng, const Value& val, SortPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); +} + + } // namespace range + using range::equal_range; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/fill.hpp b/include/boost/range/algorithm/fill.hpp index cc4b352..4d4d750 100755 --- a/include/boost/range/algorithm/fill.hpp +++ b/include/boost/range/algorithm/fill.hpp @@ -17,18 +17,24 @@ namespace boost { - /// \brief template function fill - /// - /// range-based version of the fill std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Value > - inline ForwardRange& fill(ForwardRange& rng, const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - std::fill(boost::begin(rng), boost::end(rng), val); - return rng; - } + +/// \brief template function fill +/// +/// range-based version of the fill std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Value > +inline ForwardRange& fill(ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::fill(boost::begin(rng), boost::end(rng), val); + return rng; +} + + } // namespace range + using range::fill; } #endif // include guard diff --git a/include/boost/range/algorithm/fill_n.hpp b/include/boost/range/algorithm/fill_n.hpp index 2283e23..a6c32bd 100755 --- a/include/boost/range/algorithm/fill_n.hpp +++ b/include/boost/range/algorithm/fill_n.hpp @@ -18,19 +18,25 @@ namespace boost { - /// \brief template function fill_n - /// - /// range-based version of the fill_n std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Size, class Value > - inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - BOOST_ASSERT( static_cast(std::distance(boost::begin(rng), boost::end(rng))) >= n ); - std::fill_n(boost::begin(rng), n, val); - return rng; - } + +/// \brief template function fill_n +/// +/// range-based version of the fill_n std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Size, class Value > +inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_ASSERT( static_cast(std::distance(boost::begin(rng), boost::end(rng))) >= n ); + std::fill_n(boost::begin(rng), n, val); + return rng; } + } // namespace range + using range::fill_n; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/find.hpp b/include/boost/range/algorithm/find.hpp index 1f9c667..d9d5b14 100755 --- a/include/boost/range/algorithm/find.hpp +++ b/include/boost/range/algorithm/find.hpp @@ -18,49 +18,55 @@ namespace boost { - /// \brief template function find - /// - /// range-based version of the find std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - template< class SinglePassRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find( SinglePassRange& rng, const Value& val ) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - return std::find(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template< class SinglePassRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find( const SinglePassRange& rng, const Value& val ) - { - boost::function_requires< SinglePassRangeConcept >(); - return std::find(boost::begin(rng), boost::end(rng), val); - } + +/// \brief template function find +/// +/// range-based version of the find std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +template< class SinglePassRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find( SinglePassRange& rng, const Value& val ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::find(boost::begin(rng), boost::end(rng), val); +} +/// \overload +template< class SinglePassRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find( const SinglePassRange& rng, const Value& val ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::find(boost::begin(rng), boost::end(rng), val); +} // range_return overloads - /// \overload - template< range_return_value re, class SinglePassRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - find( SinglePassRange& rng, const Value& val ) - { - boost::function_requires< SinglePassRangeConcept >(); - return range_return:: - pack(std::find(boost::begin(rng), boost::end(rng), val), - rng); - } - /// \overload - template< range_return_value re, class SinglePassRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - find( const SinglePassRange& rng, const Value& val ) - { - boost::function_requires< SinglePassRangeConcept >(); - return range_return:: - pack(std::find(boost::begin(rng), boost::end(rng), val), - rng); - } +/// \overload +template< range_return_value re, class SinglePassRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +find( SinglePassRange& rng, const Value& val ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return range_return:: + pack(std::find(boost::begin(rng), boost::end(rng), val), + rng); +} +/// \overload +template< range_return_value re, class SinglePassRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +find( const SinglePassRange& rng, const Value& val ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return range_return:: + pack(std::find(boost::begin(rng), boost::end(rng), val), + rng); +} + + } // namespace range + using range::find; } #endif // include guard diff --git a/include/boost/range/algorithm/find_end.hpp b/include/boost/range/algorithm/find_end.hpp index a16478a..aaf4888 100755 --- a/include/boost/range/algorithm/find_end.hpp +++ b/include/boost/range/algorithm/find_end.hpp @@ -18,119 +18,125 @@ namespace boost { - /// \brief template function find_end - /// - /// range-based version of the find_end std algorithm - /// - /// \pre ForwardRange1 is a model of the ForwardRangeConcept - /// \pre ForwardRange2 is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type - find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::find_end(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } - - /// \overload - template< class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_end(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } - - /// \overload - template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_end(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } - - /// \overload - template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_end(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } - - /// \overload - template< range_return_value re, class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_end(ForwardRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_end(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)), - rng1); - } - - /// \overload - template< range_return_value re, class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_end(const ForwardRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_end(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)), - rng1); - } - - /// \overload - template< range_return_value re, class ForwardRange1, class ForwardRange2, - class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_end(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred), - rng1); - } - - /// \overload - template< range_return_value re, class ForwardRange1, class ForwardRange2, - class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_end(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred), - rng1); - } +/// \brief template function find_end +/// +/// range-based version of the find_end std algorithm +/// +/// \pre ForwardRange1 is a model of the ForwardRangeConcept +/// \pre ForwardRange2 is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template< class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type +find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::find_end(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2)); } +/// \overload +template< class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2) +{ + + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_end(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2)); +} + +/// \overload +template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_end(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred); +} + +/// \overload +template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_end(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred); +} + +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_end(ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_end(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)), + rng1); +} + +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_end(const ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_end(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)), + rng1); +} + +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2, + class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_end(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred), + rng1); +} + +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2, + class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_end(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred), + rng1); +} + + } // namespace range + using range::find_end; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/find_first_of.hpp b/include/boost/range/algorithm/find_first_of.hpp index 70d143c..3902cd0 100755 --- a/include/boost/range/algorithm/find_first_of.hpp +++ b/include/boost/range/algorithm/find_first_of.hpp @@ -18,122 +18,127 @@ namespace boost { - /// \brief template function find_first_of - /// - /// range-based version of the find_first_of std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre ForwardRange2 is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< class SinglePassRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::find_first_of(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } - - /// \overload - template< class SinglePassRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_first_of(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } - - /// \overload - template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_first_of(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } - - /// \overload - template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return std::find_first_of(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } - -// range return overloads - /// \overload - template< range_return_value re, class SinglePassRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)), - rng1); - } - - /// \overload - template< range_return_value re, class SinglePassRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)), - rng1); - } - - /// \overload - template< range_return_value re, class SinglePassRange1, class ForwardRange2, - class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred), - rng1); - } - - /// \overload - template< range_return_value re, class SinglePassRange1, class ForwardRange2, - class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - - return range_return:: - pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2),pred), - rng1); - } +/// \brief template function find_first_of +/// +/// range-based version of the find_first_of std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre ForwardRange2 is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template< class SinglePassRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::find_first_of(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2)); } +/// \overload +template< class SinglePassRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_first_of(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2)); +} + +/// \overload +template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_first_of(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred); +} + +/// \overload +template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return std::find_first_of(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred); +} + +// range return overloads +/// \overload +template< range_return_value re, class SinglePassRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)), + rng1); +} + +/// \overload +template< range_return_value re, class SinglePassRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)), + rng1); +} + +/// \overload +template< range_return_value re, class SinglePassRange1, class ForwardRange2, + class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred), + rng1); +} + +/// \overload +template< range_return_value re, class SinglePassRange1, class ForwardRange2, + class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + + return range_return:: + pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2),pred), + rng1); +} + + } // namespace range + using range::find_first_of; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/find_if.hpp b/include/boost/range/algorithm/find_if.hpp index 9d13f29..f36c4e5 100755 --- a/include/boost/range/algorithm/find_if.hpp +++ b/include/boost/range/algorithm/find_if.hpp @@ -18,52 +18,56 @@ namespace boost { - /// \brief template function find_if - /// - /// range-based version of the find_if std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre UnaryPredicate is a model of the UnaryPredicateConcept - template< class SinglePassRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_if( SinglePassRange& rng, UnaryPredicate pred ) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - return std::find_if(boost::begin(rng), boost::end(rng), pred); - } - /// \overload - template< class SinglePassRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - find_if( const SinglePassRange& rng, UnaryPredicate pred ) - { - boost::function_requires< SinglePassRangeConcept >(); - return std::find_if(boost::begin(rng), boost::end(rng), pred); - } + +/// \brief template function find_if +/// +/// range-based version of the find_if std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre UnaryPredicate is a model of the UnaryPredicateConcept +template< class SinglePassRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_if( SinglePassRange& rng, UnaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::find_if(boost::begin(rng), boost::end(rng), pred); +} +/// \overload +template< class SinglePassRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +find_if( const SinglePassRange& rng, UnaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::find_if(boost::begin(rng), boost::end(rng), pred); +} // range_return overloads - /// \overload - template< range_return_value re, class SinglePassRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_if( SinglePassRange& rng, UnaryPredicate pred ) - { - boost::function_requires< SinglePassRangeConcept >(); - return range_return:: - pack(std::find_if(boost::begin(rng), boost::end(rng), pred), - rng); - } - /// \overload - template< range_return_value re, class SinglePassRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - find_if( const SinglePassRange& rng, UnaryPredicate pred ) - { - boost::function_requires< SinglePassRangeConcept >(); - return range_return:: - pack(std::find_if(boost::begin(rng), boost::end(rng), pred), - rng); - } - - +/// \overload +template< range_return_value re, class SinglePassRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_if( SinglePassRange& rng, UnaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return range_return:: + pack(std::find_if(boost::begin(rng), boost::end(rng), pred), + rng); +} +/// \overload +template< range_return_value re, class SinglePassRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +find_if( const SinglePassRange& rng, UnaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return range_return:: + pack(std::find_if(boost::begin(rng), boost::end(rng), pred), + rng); } + } // namespace range + using range::find_if; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/for_each.hpp b/include/boost/range/algorithm/for_each.hpp index 689b3e4..5145432 100755 --- a/include/boost/range/algorithm/for_each.hpp +++ b/include/boost/range/algorithm/for_each.hpp @@ -17,26 +17,32 @@ namespace boost { - /// \brief template function for_each - /// - /// range-based version of the for_each std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre UnaryFunction is a model of the UnaryFunctionConcept - template< class SinglePassRange, class UnaryFunction > - inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun) + namespace range { - boost::function_requires< SinglePassRangeConcept< SinglePassRange > >(); - return std::for_each(boost::begin(rng),boost::end(rng),fun); - } - /// \overload - template< class SinglePassRange, class UnaryFunction > - inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun) - { - boost::function_requires< SinglePassRangeConcept< SinglePassRange > >(); - return std::for_each(boost::begin(rng),boost::end(rng),fun); - } +/// \brief template function for_each +/// +/// range-based version of the for_each std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre UnaryFunction is a model of the UnaryFunctionConcept +template< class SinglePassRange, class UnaryFunction > +inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::for_each(boost::begin(rng),boost::end(rng),fun); +} + +/// \overload +template< class SinglePassRange, class UnaryFunction > +inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::for_each(boost::begin(rng),boost::end(rng),fun); +} + + } // namespace range + using range::for_each; } // namespace boost #endif // include guard diff --git a/include/boost/range/algorithm/generate.hpp b/include/boost/range/algorithm/generate.hpp index 48bdb70..7b7dde7 100755 --- a/include/boost/range/algorithm/generate.hpp +++ b/include/boost/range/algorithm/generate.hpp @@ -17,28 +17,33 @@ namespace boost { - /// \brief template function generate - /// - /// range-based version of the generate std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre Generator is a model of the UnaryFunctionConcept - template< class ForwardRange, class Generator > - inline ForwardRange& generate( ForwardRange& rng, Generator gen ) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - std::generate(boost::begin(rng), boost::end(rng), gen); - return rng; - } - - /// \overload - template< class ForwardRange, class Generator > - inline const ForwardRange& generate(const ForwardRange& rng, Generator gen) - { - boost::function_requires< ForwardRangeConcept >(); - std::generate(boost::begin(rng), boost::end(rng), gen); - return rng; - } +/// \brief template function generate +/// +/// range-based version of the generate std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre Generator is a model of the UnaryFunctionConcept +template< class ForwardRange, class Generator > +inline ForwardRange& generate( ForwardRange& rng, Generator gen ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::generate(boost::begin(rng), boost::end(rng), gen); + return rng; } +/// \overload +template< class ForwardRange, class Generator > +inline const ForwardRange& generate(const ForwardRange& rng, Generator gen) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::generate(boost::begin(rng), boost::end(rng), gen); + return rng; +} + + } // namespace range + using range::generate; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/heap_algorithm.hpp b/include/boost/range/algorithm/heap_algorithm.hpp index 411b1ab..05c9013 100755 --- a/include/boost/range/algorithm/heap_algorithm.hpp +++ b/include/boost/range/algorithm/heap_algorithm.hpp @@ -17,153 +17,162 @@ namespace boost { - /// \brief template function push_heap - /// - /// range-based version of the push_heap std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline void push_heap(RandomAccessRange& rng) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::push_heap(boost::begin(rng), boost::end(rng)); - } - /// \overload - template - inline void push_heap(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::push_heap(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline void push_heap(RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \overload - template - inline void push_heap(const RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \brief template function pop_heap - /// - /// range-based version of the pop_heap std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline void pop_heap(RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::pop_heap(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline void pop_heap(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::pop_heap(boost::begin(rng),boost::end(rng)); - } - - /// \overload - template - inline void pop_heap(RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \overload - template - inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \brief template function make_heap - /// - /// range-based version of the make_heap std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline void make_heap(RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::make_heap(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline void make_heap(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::make_heap(boost::begin(rng),boost::end(rng)); - } - - /// \overload - template - inline void make_heap(RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \overload - template - inline void make_heap(const RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \brief template function sort_heap - /// - /// range-based version of the sort_heap std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline void sort_heap(RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort_heap(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline void sort_heap(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort_heap(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline void sort_heap(RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); - } - - /// \overload - template - inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); - } +/// \brief template function push_heap +/// +/// range-based version of the push_heap std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline void push_heap(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::push_heap(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline void push_heap(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::push_heap(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline void push_heap(RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \overload +template +inline void push_heap(const RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \brief template function pop_heap +/// +/// range-based version of the pop_heap std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline void pop_heap(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::pop_heap(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline void pop_heap(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::pop_heap(boost::begin(rng),boost::end(rng)); +} + +/// \overload +template +inline void pop_heap(RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \overload +template +inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \brief template function make_heap +/// +/// range-based version of the make_heap std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline void make_heap(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::make_heap(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline void make_heap(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::make_heap(boost::begin(rng),boost::end(rng)); +} + +/// \overload +template +inline void make_heap(RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \overload +template +inline void make_heap(const RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \brief template function sort_heap +/// +/// range-based version of the sort_heap std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline void sort_heap(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort_heap(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline void sort_heap(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort_heap(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline void sort_heap(RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + +/// \overload +template +inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); +} + + } // namespace range + using range::push_heap; + using range::pop_heap; + using range::make_heap; + using range::sort_heap; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/inplace_merge.hpp b/include/boost/range/algorithm/inplace_merge.hpp index 419dabf..867b70c 100755 --- a/include/boost/range/algorithm/inplace_merge.hpp +++ b/include/boost/range/algorithm/inplace_merge.hpp @@ -17,52 +17,58 @@ namespace boost { - /// \brief template function inplace_merge - /// - /// range-based version of the inplace_merge std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type middle) + namespace range { - boost::function_requires< BidirectionalRangeConcept >(); - std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); - return rng; - } - /// \overload - template - inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, - BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle) - { - boost::function_requires< BidirectionalRangeConcept >(); - std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); - return rng; - } - - /// \overload - template - inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, - BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle, - BinaryPredicate pred) - { - boost::function_requires< BidirectionalRangeConcept >(); - std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); - return rng; - } - - /// \overload - template - inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, - BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle, - BinaryPredicate pred) - { - boost::function_requires< BidirectionalRangeConcept >(); - std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); - return rng; - } +/// \brief template function inplace_merge +/// +/// range-based version of the inplace_merge std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); + return rng; } +/// \overload +template +inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); + return rng; +} + +/// \overload +template +inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); + return rng; +} + +/// \overload +template +inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, + BOOST_DEDUCED_TYPENAME boost::range_iterator::type middle, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); + return rng; +} + + } // namespace range + using range::inplace_merge; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/lexicographical_compare.hpp b/include/boost/range/algorithm/lexicographical_compare.hpp index dc79d09..9c72526 100755 --- a/include/boost/range/algorithm/lexicographical_compare.hpp +++ b/include/boost/range/algorithm/lexicographical_compare.hpp @@ -17,36 +17,42 @@ namespace boost { - /// \brief template function lexicographic_compare - /// - /// range-based version of the lexicographic_compare std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - template - inline bool lexicographical_compare(const SinglePassRange1& rng1, - const SinglePassRange2& rng2) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::lexicographical_compare( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)); - } - /// \overload - template - inline bool lexicographical_compare(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::lexicographical_compare( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred); - } +/// \brief template function lexicographic_compare +/// +/// range-based version of the lexicographic_compare std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +template +inline bool lexicographical_compare(const SinglePassRange1& rng1, + const SinglePassRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::lexicographical_compare( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)); } +/// \overload +template +inline bool lexicographical_compare(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::lexicographical_compare( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred); +} + + } // namespace range + using range::lexicographical_compare; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/lower_bound.hpp b/include/boost/range/algorithm/lower_bound.hpp index 3bd313e..682ba36 100755 --- a/include/boost/range/algorithm/lower_bound.hpp +++ b/include/boost/range/algorithm/lower_bound.hpp @@ -18,82 +18,88 @@ namespace boost { - /// \brief template function lower_bound - /// - /// range-based version of the lower_bound std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - lower_bound( ForwardRange& rng, Value val ) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::lower_bound(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - lower_bound( const ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::lower_bound(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template< class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); - } - /// \overload - template< class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - lower_bound( ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - lower_bound( const ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), - rng); - } + +/// \brief template function lower_bound +/// +/// range-based version of the lower_bound std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +lower_bound( ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::lower_bound(boost::begin(rng), boost::end(rng), val); +} +/// \overload +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +lower_bound( const ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::lower_bound(boost::begin(rng), boost::end(rng), val); +} +/// \overload +template< class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); +} +/// \overload +template< class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +lower_bound( ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +lower_bound( const ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), + rng); } + } // namespace range + using range::lower_bound; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/max_element.hpp b/include/boost/range/algorithm/max_element.hpp index 8274ff3..3e4df5f 100755 --- a/include/boost/range/algorithm/max_element.hpp +++ b/include/boost/range/algorithm/max_element.hpp @@ -18,92 +18,98 @@ namespace boost { - /// \brief template function max_element - /// - /// range-based version of the max_element std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - max_element(ForwardRange& rng) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - 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::function_requires< ForwardRangeConcept >(); - return std::max_element(boost::begin(rng), boost::end(rng)); - } +/// \brief template function max_element +/// +/// range-based version of the max_element std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +max_element(ForwardRange& rng) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::max_element(boost::begin(rng), boost::end(rng)); +} - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - max_element(ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - 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) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::max_element(boost::begin(rng), boost::end(rng)); +} - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - max_element(const ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return std::max_element(boost::begin(rng), boost::end(rng), pred); - } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +max_element(ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::max_element(boost::begin(rng), boost::end(rng), pred); +} // range_return overloads - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - max_element(ForwardRange& rng) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::max_element(boost::begin(rng), boost::end(rng)), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - max_element(const ForwardRange& rng) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::max_element(boost::begin(rng), boost::end(rng)), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - max_element(ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::max_element(boost::begin(rng), boost::end(rng), pred), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - max_element(const ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::max_element(boost::begin(rng), boost::end(rng), pred), - rng); - } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +max_element(ForwardRange& rng) +{ + BOOST_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 +max_element(const ForwardRange& rng) +{ + BOOST_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 +max_element(ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::max_element(boost::begin(rng), boost::end(rng), pred), + rng); +} + +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +max_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/merge.hpp b/include/boost/range/algorithm/merge.hpp index 61bf7c2..7f6030c 100755 --- a/include/boost/range/algorithm/merge.hpp +++ b/include/boost/range/algorithm/merge.hpp @@ -17,39 +17,45 @@ namespace boost { - /// \brief template function merge - /// - /// range-based version of the merge std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - /// - template - inline OutputIterator merge(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::merge(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out); - } - /// \overload - template - inline OutputIterator merge(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::merge(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out, pred); - } +/// \brief template function merge +/// +/// range-based version of the merge std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +/// +template +inline OutputIterator merge(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::merge(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out); } +/// \overload +template +inline OutputIterator merge(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::merge(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out, pred); +} + + } // namespace range + using range::merge; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/min_element.hpp b/include/boost/range/algorithm/min_element.hpp index 66f87f0..1fb0f24 100755 --- a/include/boost/range/algorithm/min_element.hpp +++ b/include/boost/range/algorithm/min_element.hpp @@ -18,92 +18,98 @@ namespace boost { - /// \brief template function min_element - /// - /// range-based version of the min_element std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - min_element(ForwardRange& rng) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - 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::function_requires< ForwardRangeConcept >(); - return std::min_element(boost::begin(rng), boost::end(rng)); - } +/// \brief template function min_element +/// +/// range-based version of the min_element std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +min_element(ForwardRange& rng) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::min_element(boost::begin(rng), boost::end(rng)); +} - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - min_element(ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - 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) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::min_element(boost::begin(rng), boost::end(rng)); +} - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - min_element(const ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return std::min_element(boost::begin(rng), boost::end(rng), pred); - } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +min_element(ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::min_element(boost::begin(rng), boost::end(rng), pred); +} // range_return overloads - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - min_element(ForwardRange& rng) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::min_element(boost::begin(rng), boost::end(rng)), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - min_element(const ForwardRange& rng) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::min_element(boost::begin(rng), boost::end(rng)), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - min_element(ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::min_element(boost::begin(rng), boost::end(rng), pred), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - min_element(const ForwardRange& rng, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::min_element(boost::begin(rng), boost::end(rng), pred), - rng); - } +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +min_element(ForwardRange& rng) +{ + BOOST_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 +min_element(const ForwardRange& rng) +{ + BOOST_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 +min_element(ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::min_element(boost::begin(rng), boost::end(rng), pred), + rng); +} + +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +min_element(const ForwardRange& rng, BinaryPredicate pred) +{ + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/mismatch.hpp b/include/boost/range/algorithm/mismatch.hpp index 71198c2..c1cfa87 100755 --- a/include/boost/range/algorithm/mismatch.hpp +++ b/include/boost/range/algorithm/mismatch.hpp @@ -57,126 +57,139 @@ namespace boost return std::pair(first1, first2); } - } + } // namespace range_detail - /// \brief template function mismatch - /// - /// range-based version of the mismatch std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \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) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); +/// \brief template function mismatch +/// +/// range-based version of the mismatch std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \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_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); - return 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::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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(SinglePassRange1& rng1, SinglePassRange2 & rng2) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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, SinglePassRange2& rng2) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return 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, SinglePassRange2& rng2, BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - - return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred); - } + 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_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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(SinglePassRange1& rng1, SinglePassRange2 & rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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, SinglePassRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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, SinglePassRange2& rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/nth_element.hpp b/include/boost/range/algorithm/nth_element.hpp index d082a6a..431aa23 100755 --- a/include/boost/range/algorithm/nth_element.hpp +++ b/include/boost/range/algorithm/nth_element.hpp @@ -17,48 +17,54 @@ namespace boost { - /// \brief template function nth_element - /// - /// range-based version of the nth_element std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline void nth_element(RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type nth) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::nth_element(boost::begin(rng), nth, boost::end(rng)); - } - /// \overload - template - inline void nth_element(const RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type nth) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::nth_element(boost::begin(rng),nth,boost::end(rng)); - } - - /// \overload - template - inline void nth_element(RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type nth, - BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); - } - - /// \overload - template - inline void nth_element(const RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type nth, - BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred); - } +/// \brief template function nth_element +/// +/// range-based version of the nth_element std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline void nth_element(RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng), nth, boost::end(rng)); } +/// \overload +template +inline void nth_element(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng),nth,boost::end(rng)); +} + +/// \overload +template +inline void nth_element(RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth, + BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); +} + +/// \overload +template +inline void nth_element(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type nth, + BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred); +} + + } // namespace range + using range::nth_element; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/partial_sort.hpp b/include/boost/range/algorithm/partial_sort.hpp index a80d544..2881bd4 100755 --- a/include/boost/range/algorithm/partial_sort.hpp +++ b/include/boost/range/algorithm/partial_sort.hpp @@ -17,49 +17,55 @@ namespace boost { - /// \brief template function partial_sort - /// - /// range-based version of the partial_sort std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline void partial_sort(RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type middle) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::partial_sort(boost::begin(rng), middle, boost::end(rng)); - } - /// \overload - template - inline void partial_sort(const RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type middle) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::partial_sort(boost::begin(rng), middle, boost::end(rng)); - } - - /// \overload - template - inline void partial_sort(RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type middle, - BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::partial_sort(boost::begin(rng), middle, boost::end(rng), - sort_pred); - } - - /// \overload - template - inline void partial_sort(const RandomAccessRange& rng, - BOOST_DEDUCED_TYPENAME range_iterator::type middle, - BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred); - } +/// \brief template function partial_sort +/// +/// range-based version of the partial_sort std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline void partial_sort(RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::partial_sort(boost::begin(rng), middle, boost::end(rng)); } +/// \overload +template +inline void partial_sort(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::partial_sort(boost::begin(rng), middle, boost::end(rng)); +} + +/// \overload +template +inline void partial_sort(RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type middle, + BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::partial_sort(boost::begin(rng), middle, boost::end(rng), + sort_pred); +} + +/// \overload +template +inline void partial_sort(const RandomAccessRange& rng, + BOOST_DEDUCED_TYPENAME range_iterator::type middle, + BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred); +} + + } // namespace range + using range::partial_sort; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/partial_sort_copy.hpp b/include/boost/range/algorithm/partial_sort_copy.hpp index 5adf435..d95cf27 100755 --- a/include/boost/range/algorithm/partial_sort_copy.hpp +++ b/include/boost/range/algorithm/partial_sort_copy.hpp @@ -18,41 +18,47 @@ namespace boost { - /// \brief template function partial_sort_copy - /// - /// range-based version of the partial_sort_copy std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline typename range_iterator::type - partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2) + namespace range { - BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); - BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept)); - BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept::type, typename range_value::type>)); - BOOST_CONCEPT_ASSERT((LessThanComparableConcept::type>)); - return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2)); - } +/// \brief template function partial_sort_copy +/// +/// range-based version of the partial_sort_copy std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline typename range_iterator::type +partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2) +{ + BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); + BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept)); + BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept::type, typename range_value::type>)); + BOOST_CONCEPT_ASSERT((LessThanComparableConcept::type>)); - /// \overload - template - inline typename range_iterator::type - partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2, - BinaryPredicate pred) - { - BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); - BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept)); - BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept::type, typename range_value::type>)); - BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::type, typename range_value::type>)); - - return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred); - } + return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2)); } +/// \overload +template +inline typename range_iterator::type +partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); + BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept)); + BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept::type, typename range_value::type>)); + BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::type, typename range_value::type>)); + + return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred); +} + + } // namespace range + using range::partial_sort_copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/partition.hpp b/include/boost/range/algorithm/partition.hpp index 779a32d..f7dfbbb 100755 --- a/include/boost/range/algorithm/partition.hpp +++ b/include/boost/range/algorithm/partition.hpp @@ -18,51 +18,57 @@ namespace boost { - /// \brief template function partition - /// - /// range-based version of the partition std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - partition(ForwardRange& rng, UnaryPredicate pred) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::partition(boost::begin(rng),boost::end(rng),pred); - } - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - partition(const ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return std::partition(boost::begin(rng),boost::end(rng),pred); - } +/// \brief template function partition +/// +/// range-based version of the partition std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +partition(ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::partition(boost::begin(rng),boost::end(rng),pred); +} + +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +partition(const ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::partition(boost::begin(rng),boost::end(rng),pred); +} // range_return overloads - /// \overload - template< range_return_value re, class ForwardRange, - class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - partition(ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::range_return:: - 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::type - partition(const ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::range_return:: - 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::type +partition(ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return boost::range_return:: + 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::type +partition(const ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return boost::range_return:: + pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); +} + + } // namespace range + using range::partition; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/permutation.hpp b/include/boost/range/algorithm/permutation.hpp index 01dee35..6a80ef8 100755 --- a/include/boost/range/algorithm/permutation.hpp +++ b/include/boost/range/algorithm/permutation.hpp @@ -17,101 +17,92 @@ namespace boost { - /// \brief template function next_permutation - /// - /// range-based version of the next_permutation std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline bool next_permutation(BidirectionalRange& rng) + namespace range { - boost::function_requires< - BidirectionalRangeConcept >(); - return std::next_permutation(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline bool next_permutation(const BidirectionalRange& rng) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::next_permutation(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::next_permutation(boost::begin(rng), boost::end(rng), - comp_pred); - } - - /// \overload - template - inline bool next_permutation(const BidirectionalRange& rng, - Compare comp_pred) - { - boost::function_requires< - 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 - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - /// \pre Compare is a model of the BinaryPredicateConcept - template - inline bool prev_permutation(BidirectionalRange& rng) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::prev_permutation(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline bool prev_permutation(const BidirectionalRange& rng) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::prev_permutation(boost::begin(rng), boost::end(rng)); - } - - /// \overload - template - inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::prev_permutation(boost::begin(rng), boost::end(rng), - comp_pred); - } - - /// \overload - template - inline bool prev_permutation(const BidirectionalRange& rng, - Compare comp_pred) - { - boost::function_requires< - BidirectionalRangeConcept >(); - - return std::prev_permutation(boost::begin(rng), boost::end(rng), - comp_pred); - } +/// \brief template function next_permutation +/// +/// range-based version of the next_permutation std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline bool next_permutation(BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::next_permutation(boost::begin(rng), boost::end(rng)); } +/// \overload +template +inline bool next_permutation(const BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::next_permutation(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::next_permutation(boost::begin(rng), boost::end(rng), + comp_pred); +} + +/// \overload +template +inline bool next_permutation(const BidirectionalRange& rng, + Compare comp_pred) +{ + BOOST_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 +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +/// \pre Compare is a model of the BinaryPredicateConcept +template +inline bool prev_permutation(BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::prev_permutation(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline bool prev_permutation(const BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::prev_permutation(boost::begin(rng), boost::end(rng)); +} + +/// \overload +template +inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::prev_permutation(boost::begin(rng), boost::end(rng), + comp_pred); +} + +/// \overload +template +inline bool prev_permutation(const BidirectionalRange& rng, + Compare comp_pred) +{ + BOOST_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; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/random_shuffle.hpp b/include/boost/range/algorithm/random_shuffle.hpp index dbc35b0..b90bdd1 100755 --- a/include/boost/range/algorithm/random_shuffle.hpp +++ b/include/boost/range/algorithm/random_shuffle.hpp @@ -17,46 +17,52 @@ namespace boost { - /// \brief template function random_shuffle - /// - /// range-based version of the random_shuffle std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre Generator is a model of the UnaryFunctionConcept - template - inline RandomAccessRange& random_shuffle(RandomAccessRange& rng) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::random_shuffle(boost::begin(rng), boost::end(rng)); - return rng; - } - /// \overload - template - inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::random_shuffle(boost::begin(rng),boost::end(rng)); - return rng; - } - - /// \overload - template - inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::random_shuffle(boost::begin(rng), boost::end(rng), gen); - return rng; - } - - /// \overload - template - inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::random_shuffle(boost::begin(rng), boost::end(rng), gen); - return rng; - } +/// \brief template function random_shuffle +/// +/// range-based version of the random_shuffle std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre Generator is a model of the UnaryFunctionConcept +template +inline RandomAccessRange& random_shuffle(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::random_shuffle(boost::begin(rng), boost::end(rng)); + return rng; } +/// \overload +template +inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::random_shuffle(boost::begin(rng),boost::end(rng)); + return rng; +} + +/// \overload +template +inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::random_shuffle(boost::begin(rng), boost::end(rng), gen); + return rng; +} + +/// \overload +template +inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::random_shuffle(boost::begin(rng), boost::end(rng), gen); + return rng; +} + + } // namespace range + using range::random_shuffle; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/remove.hpp b/include/boost/range/algorithm/remove.hpp index 093d831..ed4dad0 100755 --- a/include/boost/range/algorithm/remove.hpp +++ b/include/boost/range/algorithm/remove.hpp @@ -18,53 +18,57 @@ namespace boost { - /// \brief template function remove - /// - /// range-based version of the remove std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - remove(ForwardRange& rng, const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::remove(boost::begin(rng),boost::end(rng),val); - } - /// \overload - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - remove(const ForwardRange& rng, const Value& val) - { - boost::function_requires< ForwardRangeConcept >(); - return std::remove(boost::begin(rng),boost::end(rng),val); - } - -// range_return overloads - - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - remove(ForwardRange& rng, const Value& val) - { - boost::function_requires< ForwardRangeConcept >(); - - return range_return::pack( - std::remove(boost::begin(rng), boost::end(rng), val), - rng); - } - - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - remove(const ForwardRange& rng, const Value& val) - { - boost::function_requires< ForwardRangeConcept >(); - - return range_return::pack( - std::remove(boost::begin(rng), boost::end(rng), val), - rng); - } +/// \brief template function remove +/// +/// range-based version of the remove std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +remove(ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::remove(boost::begin(rng),boost::end(rng),val); } +/// \overload +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +remove(const ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::remove(boost::begin(rng),boost::end(rng),val); +} + +// range_return overloads + +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +remove(ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::remove(boost::begin(rng), boost::end(rng), val), + rng); +} + +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +remove(const ForwardRange& rng, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::remove(boost::begin(rng), boost::end(rng), val), + rng); +} + + } // namespace range + using range::remove; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/remove_copy.hpp b/include/boost/range/algorithm/remove_copy.hpp index 75b84cb..1568240 100755 --- a/include/boost/range/algorithm/remove_copy.hpp +++ b/include/boost/range/algorithm/remove_copy.hpp @@ -17,22 +17,28 @@ namespace boost { - /// \brief template function remove_copy - /// - /// range-based version of the remove_copy std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre OutputIterator is a model of the OutputIteratorConcept - /// \pre Value is a model of the EqualityComparableConcept - /// \pre Objects of type Value can be compared for equality with objects of - /// InputIterator's value type. - template< class SinglePassRange, class OutputIterator, class Value > - inline OutputIterator - remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val); - } + +/// \brief template function remove_copy +/// +/// range-based version of the remove_copy std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre OutputIterator is a model of the OutputIteratorConcept +/// \pre Value is a model of the EqualityComparableConcept +/// \pre Objects of type Value can be compared for equality with objects of +/// InputIterator's value type. +template< class SinglePassRange, class OutputIterator, class Value > +inline OutputIterator +remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val); } + } // namespace range + using range::remove_copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/remove_if.hpp b/include/boost/range/algorithm/remove_if.hpp index 2c0bbe9..5a51d13 100755 --- a/include/boost/range/algorithm/remove_if.hpp +++ b/include/boost/range/algorithm/remove_if.hpp @@ -18,53 +18,58 @@ namespace boost { - /// \brief template function remove_if - /// - /// range-based version of the remove_if std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre UnaryPredicate is a model of the UnaryPredicateConcept - template< class ForwardRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME boost::range_iterator::type - remove_if(ForwardRange& rng, UnaryPredicate pred) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::remove_if(boost::begin(rng), boost::end(rng), pred); - } - /// \overload - template< class ForwardRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME boost::range_iterator::type - remove_if(const ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return std::remove_if(boost::begin(rng),boost::end(rng),pred); - } +/// \brief template function remove_if +/// +/// range-based version of the remove_if std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre UnaryPredicate is a model of the UnaryPredicateConcept +template< class ForwardRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME boost::range_iterator::type +remove_if(ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::remove_if(boost::begin(rng), boost::end(rng), pred); +} + +/// \overload +template< class ForwardRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME boost::range_iterator::type +remove_if(const ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::remove_if(boost::begin(rng),boost::end(rng),pred); +} // range_return overloads - /// \overload - template< range_return_value re, class ForwardRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - remove_if(ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::remove_if(boost::begin(rng), boost::end(rng), pred), - rng); - } - - /// \overload - template< range_return_value re, class ForwardRange, class UnaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - remove_if(const ForwardRange& rng, UnaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return::pack( - std::remove_if(boost::begin(rng), boost::end(rng), pred), - rng); - } - +/// \overload +template< range_return_value re, class ForwardRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +remove_if(ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::remove_if(boost::begin(rng), boost::end(rng), pred), + rng); } +/// \overload +template< range_return_value re, class ForwardRange, class UnaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +remove_if(const ForwardRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return::pack( + std::remove_if(boost::begin(rng), boost::end(rng), pred), + rng); +} + + } // namespace range + using range::remove_if; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/replace.hpp b/include/boost/range/algorithm/replace.hpp index ec105de..2d1d537 100755 --- a/include/boost/range/algorithm/replace.hpp +++ b/include/boost/range/algorithm/replace.hpp @@ -17,31 +17,37 @@ namespace boost { - /// \brief template function replace - /// - /// range-based version of the replace std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Value > - inline ForwardRange& - replace(ForwardRange& rng, const Value& what, - const Value& with_what) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - std::replace(boost::begin(rng), boost::end(rng), what, with_what); - return rng; - } - /// \overload - template< class ForwardRange, class Value > - inline const ForwardRange& - replace(const ForwardRange& rng, const Value& what, - const Value& with_what) - { - boost::function_requires< ForwardRangeConcept >(); - std::replace(boost::begin(rng), boost::end(rng), what, with_what); - return rng; - } +/// \brief template function replace +/// +/// range-based version of the replace std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Value > +inline ForwardRange& +replace(ForwardRange& rng, const Value& what, + const Value& with_what) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::replace(boost::begin(rng), boost::end(rng), what, with_what); + return rng; } +/// \overload +template< class ForwardRange, class Value > +inline const ForwardRange& +replace(const ForwardRange& rng, const Value& what, + const Value& with_what) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::replace(boost::begin(rng), boost::end(rng), what, with_what); + return rng; +} + + } // namespace range + using range::replace; +} // namespace boost; + #endif // include guard diff --git a/include/boost/range/algorithm/replace_copy.hpp b/include/boost/range/algorithm/replace_copy.hpp index f4250b1..cfdd2d5 100755 --- a/include/boost/range/algorithm/replace_copy.hpp +++ b/include/boost/range/algorithm/replace_copy.hpp @@ -17,20 +17,26 @@ namespace boost { - /// \brief template function replace_copy - /// - /// range-based version of the replace_copy std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class OutputIterator, class Value > - inline OutputIterator - replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what, - const Value& with_what) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::replace_copy(boost::begin(rng), boost::end(rng), out_it, - what, with_what); - } + +/// \brief template function replace_copy +/// +/// range-based version of the replace_copy std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class OutputIterator, class Value > +inline OutputIterator +replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what, + const Value& with_what) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::replace_copy(boost::begin(rng), boost::end(rng), out_it, + what, with_what); } + } // namespace range + using range::replace_copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/replace_copy_if.hpp b/include/boost/range/algorithm/replace_copy_if.hpp index c03cb95..ba34e38 100755 --- a/include/boost/range/algorithm/replace_copy_if.hpp +++ b/include/boost/range/algorithm/replace_copy_if.hpp @@ -17,24 +17,30 @@ namespace boost { - /// \brief template function replace_copy_if - /// - /// range-based version of the replace_copy_if std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre Predicate is a model of the PredicateConcept - /// \pre Value is convertible to Predicate's argument type - /// \pre Value is Assignable - /// \pre Value is convertible to a type in OutputIterator's set of value types. - template< class ForwardRange, class OutputIterator, class Predicate, class Value > - inline OutputIterator - replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred, - const Value& with_what) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it, - pred, with_what); - } + +/// \brief template function replace_copy_if +/// +/// range-based version of the replace_copy_if std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre Predicate is a model of the PredicateConcept +/// \pre Value is convertible to Predicate's argument type +/// \pre Value is Assignable +/// \pre Value is convertible to a type in OutputIterator's set of value types. +template< class ForwardRange, class OutputIterator, class Predicate, class Value > +inline OutputIterator +replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred, + const Value& with_what) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it, + pred, with_what); } + } // namespace range + using range::replace_copy_if; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/replace_if.hpp b/include/boost/range/algorithm/replace_if.hpp index bbee464..211e895 100755 --- a/include/boost/range/algorithm/replace_if.hpp +++ b/include/boost/range/algorithm/replace_if.hpp @@ -17,33 +17,38 @@ namespace boost { - /// \brief template function replace_if - /// - /// range-based version of the replace_if std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre UnaryPredicate is a model of the UnaryPredicateConcept - template< class ForwardRange, class UnaryPredicate, class Value > - inline ForwardRange& - replace_if(ForwardRange& rng, UnaryPredicate pred, - const Value& val) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - std::replace_if(boost::begin(rng), boost::end(rng), pred, val); - return rng; - } - - /// \overload - template< class ForwardRange, class UnaryPredicate, class Value > - inline const ForwardRange& - replace_if(const ForwardRange& rng, UnaryPredicate pred, - const Value& val) - { - boost::function_requires< ForwardRangeConcept >(); - std::replace_if(boost::begin(rng), boost::end(rng), pred, val); - return rng; - } +/// \brief template function replace_if +/// +/// range-based version of the replace_if std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre UnaryPredicate is a model of the UnaryPredicateConcept +template< class ForwardRange, class UnaryPredicate, class Value > +inline ForwardRange& + replace_if(ForwardRange& rng, UnaryPredicate pred, + const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::replace_if(boost::begin(rng), boost::end(rng), pred, val); + return rng; } +/// \overload +template< class ForwardRange, class UnaryPredicate, class Value > +inline const ForwardRange& + replace_if(const ForwardRange& rng, UnaryPredicate pred, + const Value& val) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::replace_if(boost::begin(rng), boost::end(rng), pred, val); + return rng; +} + + } // namespace range + using range::replace_if; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/reverse.hpp b/include/boost/range/algorithm/reverse.hpp index 3015d1d..bc6d960 100755 --- a/include/boost/range/algorithm/reverse.hpp +++ b/include/boost/range/algorithm/reverse.hpp @@ -18,27 +18,33 @@ namespace boost { - /// \brief template function reverse - /// - /// range-based version of the reverse std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - template - inline BidirectionalRange& reverse(BidirectionalRange& rng) + namespace range { - boost::function_requires< BidirectionalRangeConcept >(); - std::reverse(boost::begin(rng), boost::end(rng)); - return rng; - } - /// \overload - template - inline const BidirectionalRange& reverse(const BidirectionalRange& rng) - { - boost::function_requires< BidirectionalRangeConcept >(); - std::reverse(boost::begin(rng), boost::end(rng)); - return rng; - } +/// \brief template function reverse +/// +/// range-based version of the reverse std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +template +inline BidirectionalRange& reverse(BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::reverse(boost::begin(rng), boost::end(rng)); + return rng; } +/// \overload +template +inline const BidirectionalRange& reverse(const BidirectionalRange& rng) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + std::reverse(boost::begin(rng), boost::end(rng)); + return rng; +} + + } // namespace range + using range::reverse; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/reverse_copy.hpp b/include/boost/range/algorithm/reverse_copy.hpp index 817675a..47b1337 100755 --- a/include/boost/range/algorithm/reverse_copy.hpp +++ b/include/boost/range/algorithm/reverse_copy.hpp @@ -18,25 +18,31 @@ namespace boost { - /// \brief template function reverse_copy - /// - /// range-based version of the reverse_copy std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - template - inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out) + namespace range { - BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept)); - return std::reverse_copy(boost::begin(rng), boost::end(rng), out); - } - /// \overload - template - inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out) - { - BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept)); - return std::reverse_copy(boost::begin(rng), boost::end(rng), out); - } +/// \brief template function reverse_copy +/// +/// range-based version of the reverse_copy std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +template +inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::reverse_copy(boost::begin(rng), boost::end(rng), out); } +/// \overload +template +inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return std::reverse_copy(boost::begin(rng), boost::end(rng), out); +} + + } // namespace range + using range::reverse_copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/rotate.hpp b/include/boost/range/algorithm/rotate.hpp index 27eb0c9..8e6c377 100755 --- a/include/boost/range/algorithm/rotate.hpp +++ b/include/boost/range/algorithm/rotate.hpp @@ -17,30 +17,36 @@ namespace boost { - /// \brief template function rotate - /// - /// range-based version of the rotate std algorithm - /// - /// \pre Rng meets the requirements for a Forward range - template - inline ForwardRange& rotate(ForwardRange& rng, - typename range_iterator::type middle) + namespace range { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - std::rotate(boost::begin(rng), middle, boost::end(rng)); - return rng; - } - /// \overload - template - inline const ForwardRange& - rotate(const ForwardRange& rng, - typename range_iterator::type middle) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - std::rotate(boost::begin(rng), middle, boost::end(rng)); - return rng; - } +/// \brief template function rotate +/// +/// range-based version of the rotate std algorithm +/// +/// \pre Rng meets the requirements for a Forward range +template +inline ForwardRange& rotate(ForwardRange& rng, + typename range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::rotate(boost::begin(rng), middle, boost::end(rng)); + return rng; } +/// \overload +template +inline const ForwardRange& + rotate(const ForwardRange& rng, + typename range_iterator::type middle) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + std::rotate(boost::begin(rng), middle, boost::end(rng)); + return rng; +} + + } // namespace range + using range::rotate; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/rotate_copy.hpp b/include/boost/range/algorithm/rotate_copy.hpp index 123ea04..6751101 100755 --- a/include/boost/range/algorithm/rotate_copy.hpp +++ b/include/boost/range/algorithm/rotate_copy.hpp @@ -18,6 +18,9 @@ namespace boost { + namespace range + { + /// \brief template function rotate /// /// range-based version of the rotate std algorithm @@ -30,9 +33,12 @@ namespace boost OutputIterator target ) { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target); } -} + + } // namespace range + using range::rotate_copy; +} // namespace boost #endif // include guard diff --git a/include/boost/range/algorithm/search.hpp b/include/boost/range/algorithm/search.hpp index 62f61e0..70526ad 100755 --- a/include/boost/range/algorithm/search.hpp +++ b/include/boost/range/algorithm/search.hpp @@ -18,114 +18,119 @@ namespace boost { - /// \brief template function search - /// - /// range-based version of the search std algorithm - /// - /// \pre ForwardRange1 is a model of the ForwardRangeConcept - /// \pre ForwardRange2 is a model of the ForwardRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - search(ForwardRange1& rng1, const ForwardRange2& rng2) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::search(boost::begin(rng1),boost::end(rng1), - 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::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::search(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } +/// \brief template function search +/// +/// range-based version of the search std algorithm +/// +/// \pre ForwardRange1 is a model of the ForwardRangeConcept +/// \pre ForwardRange2 is a model of the ForwardRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template< class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search(ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_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 - search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::search(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } +/// \overload +template< class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_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 - search(const ForwardRange1& rng1, const ForwardRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return std::search(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred); - } +/// \overload +template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::search(boost::begin(rng1),boost::end(rng1), + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::search(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),pred); +} // range_return overloads - /// \overload - template< range_return_value re, class ForwardRange1, class ForwardRange2 > - inline BOOST_DEDUCED_TYPENAME range_return::type - search(ForwardRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< 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 > - inline BOOST_DEDUCED_TYPENAME range_return::type - search(const ForwardRange1& rng1, const ForwardRange2& rng2) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< 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 > - inline BOOST_DEDUCED_TYPENAME range_return::type - search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) - { - boost::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::search(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),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::function_requires< ForwardRangeConcept >(); - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::search(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2),pred), - rng1); - } - +/// \overload +template< range_return_value re, class ForwardRange1, class ForwardRange2 > +inline BOOST_DEDUCED_TYPENAME range_return::type +search(ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_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 > +inline BOOST_DEDUCED_TYPENAME range_return::type +search(const ForwardRange1& rng1, const ForwardRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_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 > +inline BOOST_DEDUCED_TYPENAME range_return::type +search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::search(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2),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_CONCEPT_ASSERT(( ForwardRangeConcept )); + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/search_n.hpp b/include/boost/range/algorithm/search_n.hpp index 65f2510..d7b84ae 100755 --- a/include/boost/range/algorithm/search_n.hpp +++ b/include/boost/range/algorithm/search_n.hpp @@ -19,122 +19,127 @@ namespace boost { - /// \brief template function search - /// - /// range-based version of the search std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - /// \pre Integer is an integral type - /// \pre Value 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 - template< typename ForwardRange, typename Integer, typename Value > - inline typename range_iterator::type - search_n(ForwardRange& rng, Integer count, const Value& value) + namespace range { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - return std::search_n(boost::begin(rng),boost::end(rng), count, value); - } - /// \overload - template< typename ForwardRange, typename Integer, typename Value > - inline typename range_iterator::type - search_n(const ForwardRange& rng, Integer count, const Value& value) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - return std::search_n(boost::begin(rng), boost::end(rng), count, value); - } +/// \brief template function search +/// +/// range-based version of the search std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +/// \pre Integer is an integral type +/// \pre Value 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 +template< typename ForwardRange, typename Integer, typename Value > +inline typename range_iterator::type +search_n(ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + 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::type - search_n(ForwardRange& rng, Integer count, const Value& value, - BinaryPredicate binary_pred) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::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 > +inline typename range_iterator::type +search_n(const ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + return std::search_n(boost::begin(rng), boost::end(rng), count, value); +} - /// \overload - template< typename ForwardRange, typename Integer, typename Value, - typename BinaryPredicate > - inline typename range_iterator::type - search_n(const ForwardRange& rng, Integer count, const Value& value, - BinaryPredicate binary_pred) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::type, const Value&>)); - return std::search_n(boost::begin(rng), boost::end(rng), - count, value, binary_pred); - } +/// \overload +template< typename ForwardRange, typename Integer, class Value, + typename BinaryPredicate > +inline typename range_iterator::type +search_n(ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate binary_pred) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::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::type +search_n(const ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate binary_pred) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_CONCEPT_ASSERT((BinaryPredicateConcept::type, const Value&>)); + return std::search_n(boost::begin(rng), boost::end(rng), + count, value, binary_pred); +} // range_return overloads - /// \overload - template< range_return_value re, typename ForwardRange, typename Integer, - typename Value > - inline typename range_return::type - search_n(ForwardRange& rng, Integer count, const Value& value) - { - BOOST_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, typename ForwardRange, typename Integer, - class Value > - inline typename range_return::type - search_n(const ForwardRange& rng, Integer count, const Value& value) - { - BOOST_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, typename ForwardRange, typename Integer, - typename Value, typename BinaryPredicate > - inline typename range_return::type - search_n(ForwardRange& rng, Integer count, const Value& value, - BinaryPredicate pred) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_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, typename ForwardRange, typename Integer, - typename Value, typename BinaryPredicate > - inline typename range_return::type - search_n(const ForwardRange& rng, Integer count, const Value& value, - BinaryPredicate pred) - { - BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); - BOOST_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, typename ForwardRange, typename Integer, + typename Value > +inline typename range_return::type +search_n(ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_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, typename ForwardRange, typename Integer, + class Value > +inline typename range_return::type +search_n(const ForwardRange& rng, Integer count, const Value& value) +{ + BOOST_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, typename ForwardRange, typename Integer, + typename Value, typename BinaryPredicate > +inline typename range_return::type +search_n(ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_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, typename ForwardRange, typename Integer, + typename Value, typename BinaryPredicate > +inline typename range_return::type +search_n(const ForwardRange& rng, Integer count, const Value& value, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT((ForwardRangeConcept)); + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/set_algorithm.hpp b/include/boost/range/algorithm/set_algorithm.hpp index 48580a9..ce7e9b1 100755 --- a/include/boost/range/algorithm/set_algorithm.hpp +++ b/include/boost/range/algorithm/set_algorithm.hpp @@ -17,172 +17,182 @@ namespace boost { - /// \brief template function includes - /// - /// range-based version of the includes std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline bool includes(const SinglePassRange1& rng1, - const SinglePassRange2& rng2) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::includes(boost::begin(rng1),boost::end(rng1), - boost::begin(rng2),boost::end(rng2)); - } - /// \overload - template - inline bool includes(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::includes(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), pred); - } - - /// \brief template function set_union - /// - /// range-based version of the set_union std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline OutputIterator set_union(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_union(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out); - } - - /// \overload - template - inline OutputIterator set_union(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_union(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out, pred); - } - - /// \brief template function set_intersection - /// - /// range-based version of the set_intersection std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline OutputIterator set_intersection(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_intersection(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out); - } - - /// \overload - template - inline OutputIterator set_intersection(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_intersection(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), - out, pred); - } - - /// \brief template function set_difference - /// - /// range-based version of the set_difference std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline OutputIterator set_difference(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_difference(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out); - } - - /// \overload - template - inline OutputIterator set_difference(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_difference( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out, pred); - } - - /// \brief template function set_symmetric_difference - /// - /// range-based version of the set_symmetric_difference std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline OutputIterator - set_symmetric_difference(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out); - } - - /// \overload - template - inline OutputIterator - set_symmetric_difference(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryPredicate pred) - { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return std::set_symmetric_difference( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), out, pred); - } +/// \brief template function includes +/// +/// range-based version of the includes std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline bool includes(const SinglePassRange1& rng1, + const SinglePassRange2& rng2) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::includes(boost::begin(rng1),boost::end(rng1), + boost::begin(rng2),boost::end(rng2)); } +/// \overload +template +inline bool includes(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::includes(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), pred); +} + +/// \brief template function set_union +/// +/// range-based version of the set_union std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline OutputIterator set_union(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_union(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out); +} + +/// \overload +template +inline OutputIterator set_union(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_union(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out, pred); +} + +/// \brief template function set_intersection +/// +/// range-based version of the set_intersection std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline OutputIterator set_intersection(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_intersection(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out); +} + +/// \overload +template +inline OutputIterator set_intersection(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_intersection(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), + out, pred); +} + +/// \brief template function set_difference +/// +/// range-based version of the set_difference std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline OutputIterator set_difference(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_difference(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out); +} + +/// \overload +template +inline OutputIterator set_difference(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_difference( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out, pred); +} + +/// \brief template function set_symmetric_difference +/// +/// range-based version of the set_symmetric_difference std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline OutputIterator +set_symmetric_difference(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out); +} + +/// \overload +template +inline OutputIterator +set_symmetric_difference(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::set_symmetric_difference( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), out, pred); +} + + } // namespace range + using range::includes; + using range::set_union; + using range::set_intersection; + using range::set_difference; + using range::set_symmetric_difference; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/sort.hpp b/include/boost/range/algorithm/sort.hpp index 78669b0..238c48d 100755 --- a/include/boost/range/algorithm/sort.hpp +++ b/include/boost/range/algorithm/sort.hpp @@ -17,47 +17,52 @@ namespace boost { - /// \brief template function sort - /// - /// range-based version of the sort std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline RandomAccessRange& sort(RandomAccessRange& rng) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort(boost::begin(rng), boost::end(rng)); - return rng; - } - - /// \overload - template - inline const RandomAccessRange& sort(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort(boost::begin(rng),boost::end(rng)); - return rng; - } - - /// \overload - template - inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort(boost::begin(rng), boost::end(rng), pred); - return rng; - } - - /// \overload - template - inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::sort(boost::begin(rng), boost::end(rng), pred); - return rng; - } +/// \brief template function sort +/// +/// range-based version of the sort std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline RandomAccessRange& sort(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort(boost::begin(rng), boost::end(rng)); + return rng; } +/// \overload +template +inline const RandomAccessRange& sort(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort(boost::begin(rng),boost::end(rng)); + return rng; +} + +/// \overload +template +inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort(boost::begin(rng), boost::end(rng), pred); + return rng; +} + +/// \overload +template +inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::sort(boost::begin(rng), boost::end(rng), pred); + return rng; +} + + } // namespace range + using range::sort; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/stable_partition.hpp b/include/boost/range/algorithm/stable_partition.hpp index b0c6cc8..46cb616 100755 --- a/include/boost/range/algorithm/stable_partition.hpp +++ b/include/boost/range/algorithm/stable_partition.hpp @@ -18,51 +18,56 @@ namespace boost { - /// \brief template function stable_partition - /// - /// range-based version of the stable_partition std algorithm - /// - /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept - /// \pre UnaryPredicate is a model of the UnaryPredicateConcept - template - inline BOOST_DEDUCED_TYPENAME range_iterator::type - stable_partition(BidirectionalRange& rng, UnaryPredicate pred) + namespace range { - boost::function_requires< BidirectionalRangeConcept >(); - 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::function_requires< BidirectionalRangeConcept >(); - return std::stable_partition(boost::begin(rng),boost::end(rng),pred); - } - -// range_return overloads - template - inline BOOST_DEDUCED_TYPENAME range_return::type - stable_partition(BidirectionalRange& rng, UnaryPredicate pred) - { - boost::function_requires< BidirectionalRangeConcept >(); - return range_return::pack( - std::stable_partition(boost::begin(rng), boost::end(rng), pred), - rng); - } - - /// \overload - template - inline BOOST_DEDUCED_TYPENAME range_return::type - stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) - { - boost::function_requires< BidirectionalRangeConcept >(); - return range_return::pack( - std::stable_partition(boost::begin(rng),boost::end(rng),pred), - rng); - } +/// \brief template function stable_partition +/// +/// range-based version of the stable_partition std algorithm +/// +/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept +/// \pre UnaryPredicate is a model of the UnaryPredicateConcept +template +inline BOOST_DEDUCED_TYPENAME range_iterator::type +stable_partition(BidirectionalRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + 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_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 +stable_partition(BidirectionalRange& rng, UnaryPredicate pred) +{ + BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept )); + return range_return::pack( + std::stable_partition(boost::begin(rng), boost::end(rng), pred), + rng); +} + +/// \overload +template +inline BOOST_DEDUCED_TYPENAME range_return::type +stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) +{ + BOOST_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 + #endif // include guard diff --git a/include/boost/range/algorithm/stable_sort.hpp b/include/boost/range/algorithm/stable_sort.hpp index fba48d9..700933e 100755 --- a/include/boost/range/algorithm/stable_sort.hpp +++ b/include/boost/range/algorithm/stable_sort.hpp @@ -17,46 +17,52 @@ namespace boost { - /// \brief template function stable_sort - /// - /// range-based version of the stable_sort std algorithm - /// - /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template - inline RandomAccessRange& stable_sort(RandomAccessRange& rng) + namespace range { - boost::function_requires< RandomAccessRangeConcept >(); - std::stable_sort(boost::begin(rng), boost::end(rng)); - return rng; - } - /// \overload - template - inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::stable_sort(boost::begin(rng), boost::end(rng)); - return rng; - } - - /// \overload - template - inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); - return rng; - } - - /// \overload - template - inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred) - { - boost::function_requires< RandomAccessRangeConcept >(); - std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); - return rng; - } +/// \brief template function stable_sort +/// +/// range-based version of the stable_sort std algorithm +/// +/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template +inline RandomAccessRange& stable_sort(RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::stable_sort(boost::begin(rng), boost::end(rng)); + return rng; } +/// \overload +template +inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::stable_sort(boost::begin(rng), boost::end(rng)); + return rng; +} + +/// \overload +template +inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); + return rng; +} + +/// \overload +template +inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred) +{ + BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept )); + std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); + return rng; +} + + } // namespace range + using range::stable_sort; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/swap_ranges.hpp b/include/boost/range/algorithm/swap_ranges.hpp index 0b64b9c..ffc0fc8 100755 --- a/include/boost/range/algorithm/swap_ranges.hpp +++ b/include/boost/range/algorithm/swap_ranges.hpp @@ -57,25 +57,31 @@ namespace boost } } // namespace range_detail - /// \brief template function swap_ranges - /// - /// range-based version of the swap_ranges std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - template< typename SinglePassRange1, typename SinglePassRange2 > - inline SinglePassRange2& - swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2) + namespace range { - BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); - BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); - boost::range_detail::swap_ranges_impl( - boost::begin(range1), boost::end(range1), - boost::begin(range2), boost::end(range2)); +/// \brief template function swap_ranges +/// +/// range-based version of the swap_ranges std algorithm +/// +/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept +/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept +template< typename SinglePassRange1, typename SinglePassRange2 > +inline SinglePassRange2& +swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2) +{ + BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); + BOOST_CONCEPT_ASSERT((SinglePassRangeConcept)); - return range2; - } + boost::range_detail::swap_ranges_impl( + boost::begin(range1), boost::end(range1), + boost::begin(range2), boost::end(range2)); + + return range2; } + } // namespace range + using range::swap_ranges; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/transform.hpp b/include/boost/range/algorithm/transform.hpp index ca3e956..d12904b 100755 --- a/include/boost/range/algorithm/transform.hpp +++ b/include/boost/range/algorithm/transform.hpp @@ -18,25 +18,31 @@ namespace boost { - /// \brief template function transform - /// - /// range-based version of the transform std algorithm - /// - /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept - /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept - /// \pre OutputIterator is a model of the OutputIteratorConcept - /// \pre UnaryOperation is a model of the UnaryFunctionConcept - /// \pre BinaryOperation is a model of the BinaryFunctionConcept - template< class SinglePassRange1, - class OutputIterator, - class UnaryOperation > - inline OutputIterator - transform(const SinglePassRange1& rng, - OutputIterator out, - UnaryOperation fun) + namespace range { - return std::transform(boost::begin(rng),boost::end(rng),out,fun); - } + + /// \brief template function transform + /// + /// range-based version of the transform std algorithm + /// + /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept + /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept + /// \pre OutputIterator is a model of the OutputIteratorConcept + /// \pre UnaryOperation is a model of the UnaryFunctionConcept + /// \pre BinaryOperation is a model of the BinaryFunctionConcept + template< class SinglePassRange1, + class OutputIterator, + class UnaryOperation > + inline OutputIterator + transform(const SinglePassRange1& rng, + OutputIterator out, + UnaryOperation fun) + { + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::transform(boost::begin(rng),boost::end(rng),out,fun); + } + + } // namespace range namespace range_detail { @@ -62,24 +68,30 @@ namespace boost } } - /// \overload - template< class SinglePassRange1, - class SinglePassRange2, - class OutputIterator, - class BinaryOperation > - inline OutputIterator - transform(const SinglePassRange1& rng1, - const SinglePassRange2& rng2, - OutputIterator out, - BinaryOperation fun) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - boost::function_requires< SinglePassRangeConcept >(); - return range_detail::transform_impl( - boost::begin(rng1), boost::end(rng1), - boost::begin(rng2), boost::end(rng2), - out, fun); - } -} + + /// \overload + template< class SinglePassRange1, + class SinglePassRange2, + class OutputIterator, + class BinaryOperation > + inline OutputIterator + transform(const SinglePassRange1& rng1, + const SinglePassRange2& rng2, + OutputIterator out, + BinaryOperation fun) + { + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return range_detail::transform_impl( + boost::begin(rng1), boost::end(rng1), + boost::begin(rng2), boost::end(rng2), + out, fun); + } + + } // namespace range + using range::transform; +} // namespace boost #endif // include guard diff --git a/include/boost/range/algorithm/unique.hpp b/include/boost/range/algorithm/unique.hpp index 8d8ee1a..43e3b82 100755 --- a/include/boost/range/algorithm/unique.hpp +++ b/include/boost/range/algorithm/unique.hpp @@ -18,84 +18,90 @@ namespace boost { - /// \brief template function unique - /// - /// range-based version of the unique std algorithm - /// - /// \pre Rng meets the requirements for a Forward range - template< range_return_value re, class ForwardRange > - inline BOOST_DEDUCED_TYPENAME range_return::type - unique( ForwardRange& rng ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack( std::unique( boost::begin(rng), - boost::end(rng)), rng ); - } + namespace range + { - /// \overload - template< range_return_value re, class ForwardRange > - inline BOOST_DEDUCED_TYPENAME range_return::type - unique( const ForwardRange& rng ) - { - boost::function_requires< 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 - unique( ForwardRange& rng, BinaryPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - 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::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::unique(boost::begin(rng), boost::end(rng), pred), - rng); - } - - /// \overload - template< class ForwardRange > - inline BOOST_DEDUCED_TYPENAME range_return::type - unique( ForwardRange& rng ) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::unique(rng); - } - /// \overload - template< class ForwardRange > - inline BOOST_DEDUCED_TYPENAME range_return::type - unique( const ForwardRange& rng ) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::unique(rng); - } - /// \overload - template< class ForwardRange, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - unique( ForwardRange& rng, BinaryPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::unique(rng); - } - /// \overload - template< class ForwardRange, class BinaryPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - unique( const ForwardRange& rng, BinaryPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return boost::unique(rng, pred); - } +/// \brief template function unique +/// +/// range-based version of the unique std algorithm +/// +/// \pre Rng meets the requirements for a Forward range +template< range_return_value re, class ForwardRange > +inline BOOST_DEDUCED_TYPENAME range_return::type +unique( ForwardRange& rng ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack( std::unique( boost::begin(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_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 +unique( ForwardRange& rng, BinaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + 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_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::unique(boost::begin(rng), boost::end(rng), pred), + rng); +} + +/// \overload +template< class ForwardRange > +inline BOOST_DEDUCED_TYPENAME range_return::type +unique( ForwardRange& rng ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return ::boost::range::unique(rng); +} +/// \overload +template< class ForwardRange > +inline BOOST_DEDUCED_TYPENAME range_return::type +unique( const ForwardRange& rng ) +{ + BOOST_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 ) +{ + BOOST_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_CONCEPT_ASSERT(( ForwardRangeConcept )); + return ::boost::range::unique(rng, pred); +} + + } // namespace range + using range::unique; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/unique_copy.hpp b/include/boost/range/algorithm/unique_copy.hpp index 4d2a3f2..909017b 100755 --- a/include/boost/range/algorithm/unique_copy.hpp +++ b/include/boost/range/algorithm/unique_copy.hpp @@ -17,29 +17,35 @@ namespace boost { - /// \brief template function unique_copy - /// - /// range-based version of the unique_copy std algorithm - /// - /// \pre SinglePassRange is a model of the SinglePassRangeConcept - /// \pre OutputIterator is a model of the OutputIteratorConcept - /// \pre BinaryPredicate is a model of the BinaryPredicateConcept - template< class SinglePassRange, class OutputIterator > - inline OutputIterator - unique_copy( const SinglePassRange& rng, OutputIterator out_it ) - { - boost::function_requires< SinglePassRangeConcept >(); - return std::unique_copy(boost::begin(rng), boost::end(rng), out_it); - } - /// \overload - template< class SinglePassRange, class OutputIterator, class BinaryPredicate > - inline OutputIterator - unique_copy( const SinglePassRange& rng, OutputIterator out_it, - BinaryPredicate pred ) + namespace range { - boost::function_requires< SinglePassRangeConcept >(); - return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred); - } + +/// \brief template function unique_copy +/// +/// range-based version of the unique_copy std algorithm +/// +/// \pre SinglePassRange is a model of the SinglePassRangeConcept +/// \pre OutputIterator is a model of the OutputIteratorConcept +/// \pre BinaryPredicate is a model of the BinaryPredicateConcept +template< class SinglePassRange, class OutputIterator > +inline OutputIterator +unique_copy( const SinglePassRange& rng, OutputIterator out_it ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::unique_copy(boost::begin(rng), boost::end(rng), out_it); +} +/// \overload +template< class SinglePassRange, class OutputIterator, class BinaryPredicate > +inline OutputIterator +unique_copy( const SinglePassRange& rng, OutputIterator out_it, + BinaryPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept )); + return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred); } + } // namespace range + using range::unique_copy; +} // namespace boost + #endif // include guard diff --git a/include/boost/range/algorithm/upper_bound.hpp b/include/boost/range/algorithm/upper_bound.hpp index 8d17abf..e11acad 100755 --- a/include/boost/range/algorithm/upper_bound.hpp +++ b/include/boost/range/algorithm/upper_bound.hpp @@ -18,84 +18,90 @@ namespace boost { - /// \brief template function upper_bound - /// - /// range-based version of the upper_bound std algorithm - /// - /// \pre ForwardRange is a model of the ForwardRangeConcept - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - upper_bound( ForwardRange& rng, Value val ) + namespace range { - boost::function_requires< ForwardRangeConcept >(); - return std::upper_bound(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template< class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - upper_bound( const ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::upper_bound(boost::begin(rng), boost::end(rng), val); - } - /// \overload - template< class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); - } - /// \overload - template< class ForwardRange, class Value, class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_iterator::type - upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - upper_bound( ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value > - inline BOOST_DEDUCED_TYPENAME range_return::type - upper_bound( const ForwardRange& rng, Value val ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value, - class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), - rng); - } - /// \overload - template< range_return_value re, class ForwardRange, class Value, - class SortPredicate > - inline BOOST_DEDUCED_TYPENAME range_return::type - upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) - { - boost::function_requires< ForwardRangeConcept >(); - return range_return:: - pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), - rng); - } + +/// \brief template function upper_bound +/// +/// range-based version of the upper_bound std algorithm +/// +/// \pre ForwardRange is a model of the ForwardRangeConcept +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +upper_bound( ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::upper_bound(boost::begin(rng), boost::end(rng), val); +} +/// \overload +template< class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +upper_bound( const ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::upper_bound(boost::begin(rng), boost::end(rng), val); +} +/// \overload +template< class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); +} +/// \overload +template< class ForwardRange, class Value, class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_iterator::type +upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +upper_bound( ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value > +inline BOOST_DEDUCED_TYPENAME range_return::type +upper_bound( const ForwardRange& rng, Value val ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value, + class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), + rng); +} +/// \overload +template< range_return_value re, class ForwardRange, class Value, + class SortPredicate > +inline BOOST_DEDUCED_TYPENAME range_return::type +upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) +{ + BOOST_CONCEPT_ASSERT(( ForwardRangeConcept )); + return range_return:: + pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), + rng); } + } // namespace range + using range::upper_bound; +} // namespace boost + #endif // include guard