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