boostorg/range
1
0
Fork 1
mirror of https://github.com/boostorg/range.git synced 2025-07-12 20:26:44 +02:00
Code Issues Packages Projects Releases Wiki Activity

Boost.Range algorithms are now in the boost::range namespace and brought into boost by the appropriate using statement. This allows better interoperation with Boost.Algorithm since errors only occur when the use calls similarly named ambiguous functions. In this event the user can disambiguate by using algorithm::xxx() or range::xxx(). This iteration also updates the concept assert code in the range algorithms.

Browse Source 
[SVN r61023]
This commit is contained in:
Neil Groves
2010-04-03 19:14:13 +00:00
parent b4ae711d4e
commit 22c72c53eb
52 changed files with 2766 additions and 2461 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -19,6 +19,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function adjacent_find /// \brief template function adjacent_find
/// ///
/// range-based version of the adjacent_find std algorithm /// range-based version of the adjacent_find std algorithm
@ -114,6 +117,9 @@ namespace boost
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng); rng);
} }
}
} // namespace range
using range::adjacent_find;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function binary_search /// \brief template function binary_search
/// ///
/// range-based version of the binary_search std algorithm /// range-based version of the binary_search std algorithm
@ -26,7 +29,7 @@ namespace boost
template<class ForwardRange, class Value> template<class ForwardRange, class Value>
inline bool binary_search(const ForwardRange& rng, const Value& val) inline bool binary_search(const ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val); return std::binary_search(boost::begin(rng), boost::end(rng), val);
} }
@ -35,9 +38,12 @@ namespace boost
inline bool binary_search(const ForwardRange& rng, const Value& val, inline bool binary_search(const ForwardRange& rng, const Value& val,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val, pred); return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
} }
}
} // namespace range
using range::binary_search;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function copy /// \brief template function copy
/// ///
/// range-based version of the copy std algorithm /// range-based version of the copy std algorithm
@ -27,9 +30,12 @@ namespace boost
template< class SinglePassRange, class OutputIterator > template< class SinglePassRange, class OutputIterator >
inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out) inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
{ {
//BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::copy(boost::begin(rng),boost::end(rng),out); return std::copy(boost::begin(rng),boost::end(rng),out);
} }
}
} // namespace range
using range::copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function copy_backward /// \brief template function copy_backward
/// ///
/// range-based version of the copy_backwards std algorithm /// range-based version of the copy_backwards std algorithm
@ -29,9 +32,12 @@ namespace boost
copy_backward(const BidirectionalRange& rng, copy_backward(const BidirectionalRange& rng,
BidirectionalTraversalWriteableIterator out) BidirectionalTraversalWriteableIterator out)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::copy_backward(boost::begin(rng), boost::end(rng), out); return std::copy_backward(boost::begin(rng), boost::end(rng), out);
} }
}
} // namespace range
using range::copy_backward;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function count /// \brief template function count
/// ///
/// range-based version of the count std algorithm /// range-based version of the count std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val) count(SinglePassRange& rng, const Value& val)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val); return std::count(boost::begin(rng), boost::end(rng), val);
} }
@ -36,9 +39,12 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
count(const SinglePassRange& rng, const Value& val) count(const SinglePassRange& rng, const Value& val)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val); return std::count(boost::begin(rng), boost::end(rng), val);
} }
}
} // namespace range
using range::count;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function count_if /// \brief template function count_if
/// ///
/// range-based version of the count_if std algorithm /// range-based version of the count_if std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
count_if(SinglePassRange& rng, UnaryPredicate pred) count_if(SinglePassRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred); return std::count_if(boost::begin(rng), boost::end(rng), pred);
} }
@ -37,9 +40,12 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
count_if(const SinglePassRange& rng, UnaryPredicate pred) count_if(const SinglePassRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred); return std::count_if(boost::begin(rng), boost::end(rng), pred);
} }
}
} // namespace range
using range::count_if;
} // namespace boost
#endif // include guard #endif // include guard

30
include/boost/range/algorithm/equal.hpp
View File

@ -144,7 +144,10 @@ namespace boost
return equal_impl(first1, last1, first2, last2, pred, tag1, tag2); return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
} }
} } // namespace range_detail
namespace range
{
/// \brief template function equal /// \brief template function equal
/// ///
@ -156,12 +159,12 @@ namespace boost
template< class SinglePassRange1, class SinglePassRange2 > template< class SinglePassRange1, class SinglePassRange2 >
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 ) inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::equal( return ::boost::range_detail::equal(
boost::begin(rng1), boost::end(rng1), ::boost::begin(rng1), ::boost::end(rng1),
boost::begin(rng2), boost::end(rng2) ); ::boost::begin(rng2), ::boost::end(rng2) );
} }
/// \overload /// \overload
@ -169,14 +172,17 @@ namespace boost
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2, inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
BinaryPredicate pred ) BinaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::equal( return ::boost::range_detail::equal(
boost::begin(rng1), boost::end(rng1), ::boost::begin(rng1), ::boost::end(rng1),
boost::begin(rng2), boost::end(rng2), ::boost::begin(rng2), ::boost::end(rng2),
pred); pred);
} }
}
} // namespace range
using range::equal;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function equal_range /// \brief template function equal_range
/// ///
/// range-based version of the equal_range std algorithm /// range-based version of the equal_range std algorithm
@ -30,7 +33,7 @@ namespace boost
> >
equal_range(ForwardRange& rng, const Value& val) equal_range(ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val); return std::equal_range(boost::begin(rng), boost::end(rng), val);
} }
@ -42,7 +45,7 @@ namespace boost
> >
equal_range(const ForwardRange& rng, const Value& val) equal_range(const ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val); return std::equal_range(boost::begin(rng), boost::end(rng), val);
} }
@ -54,7 +57,7 @@ namespace boost
> >
equal_range(ForwardRange& rng, const Value& val, SortPredicate pred) equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
} }
@ -66,9 +69,12 @@ namespace boost
> >
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred) equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
} }
}
} // namespace range
using range::equal_range;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function fill /// \brief template function fill
/// ///
/// range-based version of the fill std algorithm /// range-based version of the fill std algorithm
@ -25,10 +28,13 @@ namespace boost
template< class ForwardRange, class Value > template< class ForwardRange, class Value >
inline ForwardRange& fill(ForwardRange& rng, const Value& val) inline ForwardRange& fill(ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::fill(boost::begin(rng), boost::end(rng), val); std::fill(boost::begin(rng), boost::end(rng), val);
return rng; return rng;
} }
} // namespace range
using range::fill;
} }
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function fill_n /// \brief template function fill_n
/// ///
/// range-based version of the fill_n std algorithm /// range-based version of the fill_n std algorithm
@ -26,11 +29,14 @@ namespace boost
template< class ForwardRange, class Size, class Value > template< class ForwardRange, class Size, class Value >
inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val) inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n ); BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n );
std::fill_n(boost::begin(rng), n, val); std::fill_n(boost::begin(rng), n, val);
return rng; return rng;
} }
}
} // namespace range
using range::fill_n;
} // namespace boost
#endif // include guard #endif // include guard

14
include/boost/range/algorithm/find.hpp
View File

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function find /// \brief template function find
/// ///
/// range-based version of the find std algorithm /// range-based version of the find std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find( SinglePassRange& rng, const Value& val ) find( SinglePassRange& rng, const Value& val )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val); return std::find(boost::begin(rng), boost::end(rng), val);
} }
/// \overload /// \overload
@ -35,7 +38,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find( const SinglePassRange& rng, const Value& val ) find( const SinglePassRange& rng, const Value& val )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val); return std::find(boost::begin(rng), boost::end(rng), val);
} }
@ -46,7 +49,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find( SinglePassRange& rng, const Value& val ) find( SinglePassRange& rng, const Value& val )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>:: return range_return<SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val), pack(std::find(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -56,11 +59,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find( const SinglePassRange& rng, const Value& val ) find( const SinglePassRange& rng, const Value& val )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>:: return range_return<const SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val), pack(std::find(boost::begin(rng), boost::end(rng), val),
rng); rng);
} }
} // namespace range
using range::find;
} }
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function find_end /// \brief template function find_end
/// ///
/// range-based version of the find_end std algorithm /// range-based version of the find_end std algorithm
@ -29,8 +32,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2) find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1), return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
@ -41,8 +44,9 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2) find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1), return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
@ -53,8 +57,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1), return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
@ -65,8 +69,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1), return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
@ -77,8 +81,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2) find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>:: return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1), pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@ -91,8 +95,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2) find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>:: return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1), pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@ -106,8 +110,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>:: return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1), pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@ -122,8 +126,8 @@ namespace boost
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>:: return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1), pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@ -131,6 +135,8 @@ namespace boost
rng1); rng1);
} }
} } // namespace range
using range::find_end;
} // namespace boost
#endif // include guard #endif // include guard

39
include/boost/range/algorithm/find_first_of.hpp
View File

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function find_first_of /// \brief template function find_first_of
/// ///
/// range-based version of the find_first_of std algorithm /// range-based version of the find_first_of std algorithm
@ -29,8 +32,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2) find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1), return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
@ -41,8 +44,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2) find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1), return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
@ -53,8 +56,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1), return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
@ -66,8 +69,8 @@ namespace boost
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1), return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
@ -79,8 +82,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2) find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>:: return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@ -93,8 +96,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2) find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const SinglePassRange1,re>:: return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@ -109,8 +112,8 @@ namespace boost
find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2, find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>:: return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@ -125,8 +128,8 @@ namespace boost
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange2> ));
return range_return<const SinglePassRange1,re>:: return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@ -134,6 +137,8 @@ namespace boost
rng1); rng1);
} }
} } // namespace range
using range::find_first_of;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function find_if /// \brief template function find_if
/// ///
/// range-based version of the find_if std algorithm /// range-based version of the find_if std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find_if( SinglePassRange& rng, UnaryPredicate pred ) find_if( SinglePassRange& rng, UnaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred); return std::find_if(boost::begin(rng), boost::end(rng), pred);
} }
/// \overload /// \overload
@ -36,7 +39,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred ) find_if( const SinglePassRange& rng, UnaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred); return std::find_if(boost::begin(rng), boost::end(rng), pred);
} }
@ -47,7 +50,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find_if( SinglePassRange& rng, UnaryPredicate pred ) find_if( SinglePassRange& rng, UnaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>:: return range_return<SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred), pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -57,13 +60,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred ) find_if( const SinglePassRange& rng, UnaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>:: return range_return<const SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred), pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng); rng);
} }
} // namespace range
} using range::find_if;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function for_each /// \brief template function for_each
/// ///
/// range-based version of the for_each std algorithm /// range-based version of the for_each std algorithm
@ -26,7 +29,7 @@ namespace boost
template< class SinglePassRange, class UnaryFunction > template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun) inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
{ {
boost::function_requires< SinglePassRangeConcept< SinglePassRange > >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun); return std::for_each(boost::begin(rng),boost::end(rng),fun);
} }
@ -34,9 +37,12 @@ namespace boost
template< class SinglePassRange, class UnaryFunction > template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun) inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
{ {
boost::function_requires< SinglePassRangeConcept< SinglePassRange > >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun); return std::for_each(boost::begin(rng),boost::end(rng),fun);
} }
} // namespace range
using range::for_each;
} // namespace boost } // namespace boost
#endif // include guard #endif // include guard

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

@ -16,6 +16,8 @@
#include <algorithm> #include <algorithm>
namespace boost namespace boost
{
namespace range
{ {
/// \brief template function generate /// \brief template function generate
/// ///
@ -26,7 +28,7 @@ namespace boost
template< class ForwardRange, class Generator > template< class ForwardRange, class Generator >
inline ForwardRange& generate( ForwardRange& rng, Generator gen ) inline ForwardRange& generate( ForwardRange& rng, Generator gen )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen); std::generate(boost::begin(rng), boost::end(rng), gen);
return rng; return rng;
} }
@ -35,10 +37,13 @@ namespace boost
template< class ForwardRange, class Generator > template< class ForwardRange, class Generator >
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen) inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen); std::generate(boost::begin(rng), boost::end(rng), gen);
return rng; return rng;
} }
}
} // namespace range
using range::generate;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function push_heap /// \brief template function push_heap
/// ///
/// range-based version of the push_heap std algorithm /// range-based version of the push_heap std algorithm
@ -26,7 +29,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng) inline void push_heap(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng)); std::push_heap(boost::begin(rng), boost::end(rng));
} }
@ -34,7 +37,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void push_heap(const RandomAccessRange& rng) inline void push_heap(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng)); std::push_heap(boost::begin(rng), boost::end(rng));
} }
@ -42,7 +45,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void push_heap(RandomAccessRange& rng, Compare comp_pred) inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -50,7 +53,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred) inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -63,7 +66,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void pop_heap(RandomAccessRange& rng) inline void pop_heap(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng)); std::pop_heap(boost::begin(rng), boost::end(rng));
} }
@ -71,7 +74,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void pop_heap(const RandomAccessRange& rng) inline void pop_heap(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng),boost::end(rng)); std::pop_heap(boost::begin(rng),boost::end(rng));
} }
@ -79,7 +82,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred) inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -87,7 +90,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred) inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -100,7 +103,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void make_heap(RandomAccessRange& rng) inline void make_heap(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng)); std::make_heap(boost::begin(rng), boost::end(rng));
} }
@ -108,7 +111,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void make_heap(const RandomAccessRange& rng) inline void make_heap(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng),boost::end(rng)); std::make_heap(boost::begin(rng),boost::end(rng));
} }
@ -116,7 +119,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void make_heap(RandomAccessRange& rng, Compare comp_pred) inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -124,7 +127,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred) inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -137,7 +140,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void sort_heap(RandomAccessRange& rng) inline void sort_heap(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng)); std::sort_heap(boost::begin(rng), boost::end(rng));
} }
@ -145,7 +148,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline void sort_heap(const RandomAccessRange& rng) inline void sort_heap(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng)); std::sort_heap(boost::begin(rng), boost::end(rng));
} }
@ -153,7 +156,7 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred) inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
} }
@ -161,9 +164,15 @@ namespace boost
template<class RandomAccessRange, class Compare> template<class RandomAccessRange, class Compare>
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred) inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); 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 #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function inplace_merge /// \brief template function inplace_merge
/// ///
/// range-based version of the inplace_merge std algorithm /// range-based version of the inplace_merge std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle) BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng; return rng;
} }
@ -37,7 +40,7 @@ namespace boost
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle) BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng; return rng;
} }
@ -48,7 +51,7 @@ namespace boost
BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle, BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng; return rng;
} }
@ -59,10 +62,13 @@ namespace boost
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle, BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng; return rng;
} }
}
} // namespace range
using range::inplace_merge;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function lexicographic_compare /// \brief template function lexicographic_compare
/// ///
/// range-based version of the lexicographic_compare std algorithm /// range-based version of the lexicographic_compare std algorithm
@ -27,8 +30,8 @@ namespace boost
inline bool lexicographical_compare(const SinglePassRange1& rng1, inline bool lexicographical_compare(const SinglePassRange1& rng1,
const SinglePassRange2& rng2) const SinglePassRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare( return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1), boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)); boost::begin(rng2), boost::end(rng2));
@ -41,12 +44,15 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare( return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1), boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred); boost::begin(rng2), boost::end(rng2), pred);
} }
}
} // namespace range
using range::lexicographical_compare;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function lower_bound /// \brief template function lower_bound
/// ///
/// range-based version of the lower_bound std algorithm /// range-based version of the lower_bound std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val ) lower_bound( ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val); return std::lower_bound(boost::begin(rng), boost::end(rng), val);
} }
/// \overload /// \overload
@ -35,7 +38,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val ) lower_bound( const ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val); return std::lower_bound(boost::begin(rng), boost::end(rng), val);
} }
/// \overload /// \overload
@ -43,7 +46,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
} }
/// \overload /// \overload
@ -51,7 +54,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
} }
/// \overload /// \overload
@ -59,7 +62,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val ) lower_bound( ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -69,7 +72,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val ) lower_bound( const ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -79,7 +82,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred ) lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng); rng);
@ -89,11 +92,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred ) lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng); rng);
} }
}
} // namespace range
using range::lower_bound;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function max_element /// \brief template function max_element
/// ///
/// range-based version of the max_element std algorithm /// range-based version of the max_element std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng) max_element(ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng)); return std::max_element(boost::begin(rng), boost::end(rng));
} }
@ -37,7 +40,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng) max_element(const ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng)); return std::max_element(boost::begin(rng), boost::end(rng));
} }
@ -46,7 +49,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred) max_element(ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred); return std::max_element(boost::begin(rng), boost::end(rng), pred);
} }
@ -55,7 +58,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng, BinaryPredicate pred) max_element(const ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred); return std::max_element(boost::begin(rng), boost::end(rng), pred);
} }
@ -66,7 +69,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng) max_element(ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)), std::max_element(boost::begin(rng), boost::end(rng)),
rng); rng);
@ -77,7 +80,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng) max_element(const ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)), std::max_element(boost::begin(rng), boost::end(rng)),
rng); rng);
@ -88,7 +91,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng, BinaryPredicate pred) max_element(ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred), std::max_element(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -99,11 +102,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng, BinaryPredicate pred) max_element(const ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred), std::max_element(boost::begin(rng), boost::end(rng), pred),
rng); rng);
} }
}
} // namespace range
using range::max_element;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function merge /// \brief template function merge
/// ///
/// range-based version of the merge std algorithm /// range-based version of the merge std algorithm
@ -31,8 +34,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
OutputIterator out) OutputIterator out)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1), return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out); boost::begin(rng2), boost::end(rng2), out);
} }
@ -45,11 +48,14 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1), return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred); boost::begin(rng2), boost::end(rng2), out, pred);
} }
}
} // namespace range
using range::merge;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function min_element /// \brief template function min_element
/// ///
/// range-based version of the min_element std algorithm /// range-based version of the min_element std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng) min_element(ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng)); return std::min_element(boost::begin(rng), boost::end(rng));
} }
@ -37,7 +40,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng) min_element(const ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng)); return std::min_element(boost::begin(rng), boost::end(rng));
} }
@ -46,7 +49,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred) min_element(ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred); return std::min_element(boost::begin(rng), boost::end(rng), pred);
} }
@ -55,7 +58,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng, BinaryPredicate pred) min_element(const ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred); return std::min_element(boost::begin(rng), boost::end(rng), pred);
} }
@ -66,7 +69,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng) min_element(ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)), std::min_element(boost::begin(rng), boost::end(rng)),
rng); rng);
@ -77,7 +80,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng) min_element(const ForwardRange& rng)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)), std::min_element(boost::begin(rng), boost::end(rng)),
rng); rng);
@ -88,7 +91,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng, BinaryPredicate pred) min_element(ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred), std::min_element(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -99,11 +102,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng, BinaryPredicate pred) min_element(const ForwardRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred), std::min_element(boost::begin(rng), boost::end(rng), pred),
rng); rng);
} }
}
} // namespace range
using range::min_element;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -57,8 +57,10 @@ namespace boost
return std::pair<SinglePassTraversalReadableIterator1, return std::pair<SinglePassTraversalReadableIterator1,
SinglePassTraversalReadableIterator2>(first1, first2); SinglePassTraversalReadableIterator2>(first1, first2);
} }
} } // namespace range_detail
namespace range
{
/// \brief template function mismatch /// \brief template function mismatch
/// ///
/// range-based version of the mismatch std algorithm /// range-based version of the mismatch std algorithm
@ -72,11 +74,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2) mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2)); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
} }
/// \overload /// \overload
@ -86,11 +89,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2) mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2)); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
} }
/// \overload /// \overload
@ -100,11 +104,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2) mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2)); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
} }
/// \overload /// \overload
@ -114,11 +119,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2) mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2)); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
} }
@ -129,11 +135,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2), pred); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
} }
/// \overload /// \overload
@ -143,11 +150,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2), pred); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
} }
/// \overload /// \overload
@ -157,11 +165,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2), pred); ::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
} }
/// \overload /// \overload
@ -171,12 +180,16 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1), return ::boost::range_detail::mismatch_impl(
boost::begin(rng2), boost::end(rng2), pred); ::boost::begin(rng1), ::boost::end(rng1),
} ::boost::begin(rng2), ::boost::end(rng2), pred);
} }
} // namespace range
using range::mismatch;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function nth_element /// \brief template function nth_element
/// ///
/// range-based version of the nth_element std algorithm /// range-based version of the nth_element std algorithm
@ -27,7 +30,7 @@ namespace boost
inline void nth_element(RandomAccessRange& rng, inline void nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth) BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::nth_element(boost::begin(rng), nth, boost::end(rng)); std::nth_element(boost::begin(rng), nth, boost::end(rng));
} }
@ -36,7 +39,7 @@ namespace boost
inline void nth_element(const RandomAccessRange& rng, inline void nth_element(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth) BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng)); std::nth_element(boost::begin(rng),nth,boost::end(rng));
} }
@ -46,7 +49,7 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
BinaryPredicate sort_pred) BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
} }
@ -56,9 +59,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
BinaryPredicate sort_pred) BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred); std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
} }
}
} // namespace range
using range::nth_element;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function partial_sort /// \brief template function partial_sort
/// ///
/// range-based version of the partial_sort std algorithm /// range-based version of the partial_sort std algorithm
@ -27,7 +30,7 @@ namespace boost
inline void partial_sort(RandomAccessRange& rng, inline void partial_sort(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle) BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng)); std::partial_sort(boost::begin(rng), middle, boost::end(rng));
} }
@ -36,7 +39,7 @@ namespace boost
inline void partial_sort(const RandomAccessRange& rng, inline void partial_sort(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle) BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng)); std::partial_sort(boost::begin(rng), middle, boost::end(rng));
} }
@ -46,7 +49,7 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
BinaryPredicate sort_pred) BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng), std::partial_sort(boost::begin(rng), middle, boost::end(rng),
sort_pred); sort_pred);
} }
@ -57,9 +60,12 @@ namespace boost
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
BinaryPredicate sort_pred) BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred); std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
} }
}
} // namespace range
using range::partial_sort;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function partial_sort_copy /// \brief template function partial_sort_copy
/// ///
/// range-based version of the partial_sort_copy std algorithm /// range-based version of the partial_sort_copy std algorithm
@ -53,6 +56,9 @@ namespace boost
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred); boost::begin(rng2), boost::end(rng2), pred);
} }
}
} // namespace range
using range::partial_sort_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function partition /// \brief template function partition
/// ///
/// range-based version of the partition std algorithm /// range-based version of the partition std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
partition(ForwardRange& rng, UnaryPredicate pred) partition(ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred); return std::partition(boost::begin(rng),boost::end(rng),pred);
} }
@ -36,7 +39,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
partition(const ForwardRange& rng, UnaryPredicate pred) partition(const ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred); return std::partition(boost::begin(rng),boost::end(rng),pred);
} }
@ -48,7 +51,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
partition(ForwardRange& rng, UnaryPredicate pred) partition(ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return boost::range_return<ForwardRange,re>:: return boost::range_return<ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
} }
@ -59,10 +62,13 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
partition(const ForwardRange& rng, UnaryPredicate pred) partition(const ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return boost::range_return<const ForwardRange,re>:: return boost::range_return<const ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
} }
}
} // namespace range
using range::partition;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function next_permutation /// \brief template function next_permutation
/// ///
/// range-based version of the next_permutation std algorithm /// range-based version of the next_permutation std algorithm
@ -26,9 +29,7 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline bool next_permutation(BidirectionalRange& rng) inline bool next_permutation(BidirectionalRange& rng)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng)); return std::next_permutation(boost::begin(rng), boost::end(rng));
} }
@ -36,9 +37,7 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng) inline bool next_permutation(const BidirectionalRange& rng)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng)); return std::next_permutation(boost::begin(rng), boost::end(rng));
} }
@ -46,9 +45,7 @@ namespace boost
template<class BidirectionalRange, class Compare> template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng), return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred); comp_pred);
} }
@ -58,9 +55,7 @@ namespace boost
inline bool next_permutation(const BidirectionalRange& rng, inline bool next_permutation(const BidirectionalRange& rng,
Compare comp_pred) Compare comp_pred)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng), return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred); comp_pred);
} }
@ -74,9 +69,7 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline bool prev_permutation(BidirectionalRange& rng) inline bool prev_permutation(BidirectionalRange& rng)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng)); return std::prev_permutation(boost::begin(rng), boost::end(rng));
} }
@ -84,9 +77,7 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng) inline bool prev_permutation(const BidirectionalRange& rng)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng)); return std::prev_permutation(boost::begin(rng), boost::end(rng));
} }
@ -94,9 +85,7 @@ namespace boost
template<class BidirectionalRange, class Compare> template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng), return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred); comp_pred);
} }
@ -106,12 +95,14 @@ namespace boost
inline bool prev_permutation(const BidirectionalRange& rng, inline bool prev_permutation(const BidirectionalRange& rng,
Compare comp_pred) Compare comp_pred)
{ {
boost::function_requires< BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng), return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred); comp_pred);
} }
}
} // namespace range
using range::next_permutation;
using range::prev_permutation;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function random_shuffle /// \brief template function random_shuffle
/// ///
/// range-based version of the random_shuffle std algorithm /// range-based version of the random_shuffle std algorithm
@ -26,7 +29,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng) inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng)); std::random_shuffle(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
@ -35,7 +38,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng) inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng),boost::end(rng)); std::random_shuffle(boost::begin(rng),boost::end(rng));
return rng; return rng;
} }
@ -44,7 +47,7 @@ namespace boost
template<class RandomAccessRange, class Generator> template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen) inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen); std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng; return rng;
} }
@ -53,10 +56,13 @@ namespace boost
template<class RandomAccessRange, class Generator> template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen) inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen); std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng; return rng;
} }
}
} // namespace range
using range::random_shuffle;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function remove /// \brief template function remove
/// ///
/// range-based version of the remove std algorithm /// range-based version of the remove std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
remove(ForwardRange& rng, const Value& val) remove(ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val); return std::remove(boost::begin(rng),boost::end(rng),val);
} }
@ -36,7 +39,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
remove(const ForwardRange& rng, const Value& val) remove(const ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val); return std::remove(boost::begin(rng),boost::end(rng),val);
} }
@ -47,8 +50,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove(ForwardRange& rng, const Value& val) remove(ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val), std::remove(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -59,12 +61,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove(const ForwardRange& rng, const Value& val) remove(const ForwardRange& rng, const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val), std::remove(boost::begin(rng), boost::end(rng), val),
rng); rng);
} }
}
} // namespace range
using range::remove;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function remove_copy /// \brief template function remove_copy
/// ///
/// range-based version of the remove_copy std algorithm /// range-based version of the remove_copy std algorithm
@ -30,9 +33,12 @@ namespace boost
inline OutputIterator inline OutputIterator
remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val) remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val); return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
} }
}
} // namespace range
using range::remove_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function remove_if /// \brief template function remove_if
/// ///
/// range-based version of the remove_if std algorithm /// range-based version of the remove_if std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
remove_if(ForwardRange& rng, UnaryPredicate pred) remove_if(ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove_if(boost::begin(rng), boost::end(rng), pred); return std::remove_if(boost::begin(rng), boost::end(rng), pred);
} }
@ -37,7 +40,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred) remove_if(const ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove_if(boost::begin(rng),boost::end(rng),pred); return std::remove_if(boost::begin(rng),boost::end(rng),pred);
} }
@ -48,7 +51,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove_if(ForwardRange& rng, UnaryPredicate pred) remove_if(ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack( return range_return<ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred), std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -59,12 +62,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred) remove_if(const ForwardRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack( return range_return<const ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred), std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng); rng);
} }
} } // namespace range
using range::remove_if;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function replace /// \brief template function replace
/// ///
/// range-based version of the replace std algorithm /// range-based version of the replace std algorithm
@ -27,7 +30,7 @@ namespace boost
replace(ForwardRange& rng, const Value& what, replace(ForwardRange& rng, const Value& what,
const Value& with_what) const Value& with_what)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what); std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng; return rng;
} }
@ -38,10 +41,13 @@ namespace boost
replace(const ForwardRange& rng, const Value& what, replace(const ForwardRange& rng, const Value& what,
const Value& with_what) const Value& with_what)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what); std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng; return rng;
} }
}
} // namespace range
using range::replace;
} // namespace boost;
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function replace_copy /// \brief template function replace_copy
/// ///
/// range-based version of the replace_copy std algorithm /// range-based version of the replace_copy std algorithm
@ -27,10 +30,13 @@ namespace boost
replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what, replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
const Value& with_what) const Value& with_what)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy(boost::begin(rng), boost::end(rng), out_it, return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
what, with_what); what, with_what);
} }
}
} // namespace range
using range::replace_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function replace_copy_if /// \brief template function replace_copy_if
/// ///
/// range-based version of the replace_copy_if std algorithm /// range-based version of the replace_copy_if std algorithm
@ -31,10 +34,13 @@ namespace boost
replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred, replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
const Value& with_what) const Value& with_what)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it, return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
pred, with_what); pred, with_what);
} }
}
} // namespace range
using range::replace_copy_if;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function replace_if /// \brief template function replace_if
/// ///
/// range-based version of the replace_if std algorithm /// range-based version of the replace_if std algorithm
@ -28,7 +31,7 @@ namespace boost
replace_if(ForwardRange& rng, UnaryPredicate pred, replace_if(ForwardRange& rng, UnaryPredicate pred,
const Value& val) const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val); std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng; return rng;
} }
@ -39,11 +42,13 @@ namespace boost
replace_if(const ForwardRange& rng, UnaryPredicate pred, replace_if(const ForwardRange& rng, UnaryPredicate pred,
const Value& val) const Value& val)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val); std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng; return rng;
} }
} } // namespace range
using range::replace_if;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function reverse /// \brief template function reverse
/// ///
/// range-based version of the reverse std algorithm /// range-based version of the reverse std algorithm
@ -26,7 +29,7 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline BidirectionalRange& reverse(BidirectionalRange& rng) inline BidirectionalRange& reverse(BidirectionalRange& rng)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng)); std::reverse(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
@ -35,10 +38,13 @@ namespace boost
template<class BidirectionalRange> template<class BidirectionalRange>
inline const BidirectionalRange& reverse(const BidirectionalRange& rng) inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng)); std::reverse(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
}
} // namespace range
using range::reverse;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function reverse_copy /// \brief template function reverse_copy
/// ///
/// range-based version of the reverse_copy std algorithm /// range-based version of the reverse_copy std algorithm
@ -37,6 +40,9 @@ namespace boost
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out); return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
} }
}
} // namespace range
using range::reverse_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function rotate /// \brief template function rotate
/// ///
/// range-based version of the rotate std algorithm /// range-based version of the rotate std algorithm
@ -37,10 +40,13 @@ namespace boost
rotate(const ForwardRange& rng, rotate(const ForwardRange& rng,
typename range_iterator<const ForwardRange>::type middle) typename range_iterator<const ForwardRange>::type middle)
{ {
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng)); std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng; return rng;
} }
}
} // namespace range
using range::rotate;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function rotate /// \brief template function rotate
/// ///
/// range-based version of the rotate std algorithm /// range-based version of the rotate std algorithm
@ -30,9 +33,12 @@ namespace boost
OutputIterator target OutputIterator target
) )
{ {
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target); return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target);
} }
}
} // namespace range
using range::rotate_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function search /// \brief template function search
/// ///
/// range-based version of the search std algorithm /// range-based version of the search std algorithm
@ -29,8 +32,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2) search(ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1), return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
} }
@ -40,8 +43,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2) search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1), return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
} }
@ -51,8 +54,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1), return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
} }
@ -63,8 +66,8 @@ namespace boost
search(const ForwardRange1& rng1, const ForwardRange2& rng2, search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1), return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred); boost::begin(rng2),boost::end(rng2),pred);
} }
@ -76,8 +79,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2) search(ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>:: return range_return<ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1), pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)), boost::begin(rng2),boost::end(rng2)),
@ -89,8 +92,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2) search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>:: return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1), pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)), boost::begin(rng2),boost::end(rng2)),
@ -103,8 +106,8 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>:: return range_return<ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1), pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred), boost::begin(rng2),boost::end(rng2),pred),
@ -118,14 +121,16 @@ namespace boost
search(const ForwardRange1& rng1, const ForwardRange2& rng2, search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange1> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
boost::function_requires< ForwardRangeConcept<ForwardRange2> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>:: return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1), pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred), boost::begin(rng2),boost::end(rng2),pred),
rng1); rng1);
} }
} } // namespace range
using range::search;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -19,6 +19,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function search /// \brief template function search
/// ///
/// range-based version of the search std algorithm /// range-based version of the search std algorithm
@ -135,6 +138,8 @@ namespace boost
rng); rng);
} }
} } // namespace range
using range::search_n;
} // namespace boost
#endif // include guard #endif // include guard

52
include/boost/range/algorithm/set_algorithm.hpp
View File

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function includes /// \brief template function includes
/// ///
/// range-based version of the includes std algorithm /// range-based version of the includes std algorithm
@ -28,8 +31,8 @@ namespace boost
inline bool includes(const SinglePassRange1& rng1, inline bool includes(const SinglePassRange1& rng1,
const SinglePassRange2& rng2) const SinglePassRange2& rng2)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1),boost::end(rng1), return std::includes(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)); boost::begin(rng2),boost::end(rng2));
} }
@ -41,8 +44,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1), boost::end(rng1), return std::includes(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred); boost::begin(rng2), boost::end(rng2), pred);
} }
@ -60,8 +63,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
OutputIterator out) OutputIterator out)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1), return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out); boost::begin(rng2), boost::end(rng2), out);
} }
@ -74,8 +77,8 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1), return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred); boost::begin(rng2), boost::end(rng2), out, pred);
} }
@ -93,8 +96,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
OutputIterator out) OutputIterator out)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1), return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out); boost::begin(rng2), boost::end(rng2), out);
} }
@ -107,8 +110,8 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1), return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), boost::begin(rng2), boost::end(rng2),
out, pred); out, pred);
@ -127,8 +130,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
OutputIterator out) OutputIterator out)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference(boost::begin(rng1), boost::end(rng1), return std::set_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out); boost::begin(rng2), boost::end(rng2), out);
} }
@ -141,8 +144,8 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference( return std::set_difference(
boost::begin(rng1), boost::end(rng1), boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred); boost::begin(rng2), boost::end(rng2), out, pred);
@ -162,8 +165,8 @@ namespace boost
const SinglePassRange2& rng2, const SinglePassRange2& rng2,
OutputIterator out) OutputIterator out)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1), return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out); boost::begin(rng2), boost::end(rng2), out);
} }
@ -177,12 +180,19 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryPredicate pred) BinaryPredicate pred)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference( return std::set_symmetric_difference(
boost::begin(rng1), boost::end(rng1), boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred); 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 #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function sort /// \brief template function sort
/// ///
/// range-based version of the sort std algorithm /// range-based version of the sort std algorithm
@ -26,9 +29,8 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline RandomAccessRange& sort(RandomAccessRange& rng) inline RandomAccessRange& sort(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng)); std::sort(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
@ -36,7 +38,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline const RandomAccessRange& sort(const RandomAccessRange& rng) inline const RandomAccessRange& sort(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng),boost::end(rng)); std::sort(boost::begin(rng),boost::end(rng));
return rng; return rng;
} }
@ -45,7 +47,7 @@ namespace boost
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred) inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred); std::sort(boost::begin(rng), boost::end(rng), pred);
return rng; return rng;
} }
@ -54,10 +56,13 @@ namespace boost
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred) inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred); std::sort(boost::begin(rng), boost::end(rng), pred);
return rng; return rng;
} }
}
} // namespace range
using range::sort;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function stable_partition /// \brief template function stable_partition
/// ///
/// range-based version of the stable_partition std algorithm /// range-based version of the stable_partition std algorithm
@ -28,7 +31,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred) stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::stable_partition(boost::begin(rng), boost::end(rng), pred); return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
} }
@ -37,7 +40,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::stable_partition(boost::begin(rng),boost::end(rng),pred); return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
} }
@ -46,7 +49,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred) stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return range_return<BidirectionalRange,re>::pack( return range_return<BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng), boost::end(rng), pred), std::stable_partition(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -57,12 +60,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{ {
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >(); BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return range_return<const BidirectionalRange,re>::pack( return range_return<const BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng),boost::end(rng),pred), std::stable_partition(boost::begin(rng),boost::end(rng),pred),
rng); rng);
} }
} } // namespace range
using range::stable_partition;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function stable_sort /// \brief template function stable_sort
/// ///
/// range-based version of the stable_sort std algorithm /// range-based version of the stable_sort std algorithm
@ -26,7 +29,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng) inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng)); std::stable_sort(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
@ -35,7 +38,7 @@ namespace boost
template<class RandomAccessRange> template<class RandomAccessRange>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng) inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng)); std::stable_sort(boost::begin(rng), boost::end(rng));
return rng; return rng;
} }
@ -44,7 +47,7 @@ namespace boost
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred) inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng; return rng;
} }
@ -53,10 +56,13 @@ namespace boost
template<class RandomAccessRange, class BinaryPredicate> template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred) inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
{ {
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >(); BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng; return rng;
} }
}
} // namespace range
using range::stable_sort;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -57,6 +57,9 @@ namespace boost
} }
} // namespace range_detail } // namespace range_detail
namespace range
{
/// \brief template function swap_ranges /// \brief template function swap_ranges
/// ///
/// range-based version of the swap_ranges std algorithm /// range-based version of the swap_ranges std algorithm
@ -76,6 +79,9 @@ namespace boost
return range2; return range2;
} }
}
} // namespace range
using range::swap_ranges;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function transform /// \brief template function transform
/// ///
/// range-based version of the transform std algorithm /// range-based version of the transform std algorithm
@ -35,9 +38,12 @@ namespace boost
OutputIterator out, OutputIterator out,
UnaryOperation fun) UnaryOperation fun)
{ {
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
return std::transform(boost::begin(rng),boost::end(rng),out,fun); return std::transform(boost::begin(rng),boost::end(rng),out,fun);
} }
} // namespace range
namespace range_detail namespace range_detail
{ {
template< class SinglePassTraversalReadableIterator1, template< class SinglePassTraversalReadableIterator1,
@ -62,6 +68,9 @@ namespace boost
} }
} }
namespace range
{
/// \overload /// \overload
template< class SinglePassRange1, template< class SinglePassRange1,
class SinglePassRange2, class SinglePassRange2,
@ -73,13 +82,16 @@ namespace boost
OutputIterator out, OutputIterator out,
BinaryOperation fun) BinaryOperation fun)
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::transform_impl( return range_detail::transform_impl(
boost::begin(rng1), boost::end(rng1), boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), boost::begin(rng2), boost::end(rng2),
out, fun); out, fun);
} }
}
} // namespace range
using range::transform;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function unique /// \brief template function unique
/// ///
/// range-based version of the unique std algorithm /// range-based version of the unique std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng ) unique( ForwardRange& rng )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack( std::unique( boost::begin(rng), pack( std::unique( boost::begin(rng),
boost::end(rng)), rng ); boost::end(rng)), rng );
@ -38,7 +41,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng ) unique( const ForwardRange& rng )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack( std::unique( boost::begin(rng), pack( std::unique( boost::begin(rng),
boost::end(rng)), rng ); boost::end(rng)), rng );
@ -48,7 +51,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng, BinaryPredicate pred ) unique( ForwardRange& rng, BinaryPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred), pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -58,7 +61,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng, BinaryPredicate pred ) unique( const ForwardRange& rng, BinaryPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred), pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng); rng);
@ -69,33 +72,36 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng ) unique( ForwardRange& rng )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return boost::unique<return_begin_found>(rng); return ::boost::range::unique<return_begin_found>(rng);
} }
/// \overload /// \overload
template< class ForwardRange > template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
unique( const ForwardRange& rng ) unique( const ForwardRange& rng )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return boost::unique<return_begin_found>(rng); return ::boost::range::unique<return_begin_found>(rng);
} }
/// \overload /// \overload
template< class ForwardRange, class BinaryPredicate > template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred ) unique( ForwardRange& rng, BinaryPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return boost::unique<return_begin_found>(rng); return ::boost::range::unique<return_begin_found>(rng);
} }
/// \overload /// \overload
template< class ForwardRange, class BinaryPredicate > template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
unique( const ForwardRange& rng, BinaryPredicate pred ) unique( const ForwardRange& rng, BinaryPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return boost::unique<return_begin_found>(rng, pred); return ::boost::range::unique<return_begin_found>(rng, pred);
}
} }
} // namespace range
using range::unique;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -17,6 +17,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function unique_copy /// \brief template function unique_copy
/// ///
/// range-based version of the unique_copy std algorithm /// range-based version of the unique_copy std algorithm
@ -28,7 +31,7 @@ namespace boost
inline OutputIterator inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it ) unique_copy( const SinglePassRange& rng, OutputIterator out_it )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it); return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
} }
/// \overload /// \overload
@ -37,9 +40,12 @@ namespace boost
unique_copy( const SinglePassRange& rng, OutputIterator out_it, unique_copy( const SinglePassRange& rng, OutputIterator out_it,
BinaryPredicate pred ) BinaryPredicate pred )
{ {
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >(); BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred); return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
} }
}
} // namespace range
using range::unique_copy;
} // namespace boost
#endif // include guard #endif // include guard

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

@ -18,6 +18,9 @@
namespace boost namespace boost
{ {
namespace range
{
/// \brief template function upper_bound /// \brief template function upper_bound
/// ///
/// range-based version of the upper_bound std algorithm /// range-based version of the upper_bound std algorithm
@ -27,7 +30,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val ) upper_bound( ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val); return std::upper_bound(boost::begin(rng), boost::end(rng), val);
} }
/// \overload /// \overload
@ -35,7 +38,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val ) upper_bound( const ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val); return std::upper_bound(boost::begin(rng), boost::end(rng), val);
} }
/// \overload /// \overload
@ -43,7 +46,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
} }
/// \overload /// \overload
@ -51,7 +54,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
} }
/// \overload /// \overload
@ -59,7 +62,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val ) upper_bound( ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -69,7 +72,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val ) upper_bound( const ForwardRange& rng, Value val )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng); rng);
@ -80,7 +83,7 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred ) upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>:: return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng); rng);
@ -91,11 +94,14 @@ namespace boost
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred ) upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{ {
boost::function_requires< ForwardRangeConcept<ForwardRange> >(); BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>:: return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng); rng);
} }
}
} // namespace range
using range::upper_bound;
} // namespace boost
#endif // include guard #endif // include guard