boostorg/range
1
0
Fork 1
mirror of https://github.com/boostorg/range.git synced 2025-07-13 04:36:40 +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

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

@ -19,82 +19,85 @@
namespace boost
{
/// \brief template function adjacent_find
///
/// range-based version of the adjacent_find std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< typename ForwardRange >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng)
namespace range
{
/// \brief template function adjacent_find
///
/// range-based version of the adjacent_find std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< typename ForwardRange >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::adjacent_find(boost::begin(rng),boost::end(rng));
}
}
/// \overload
template< typename ForwardRange >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng)
{
/// \overload
template< typename ForwardRange >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::adjacent_find(boost::begin(rng),boost::end(rng));
}
}
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng, BinaryPredicate pred)
{
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
typename range_value<ForwardRange>::type>));
return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
}
}
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
/// \overload
template< typename ForwardRange, typename BinaryPredicate >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type,
typename range_value<const ForwardRange>::type>));
return std::adjacent_find(boost::begin(rng),boost::end(rng),pred);
}
}
// range_return overloads
/// \overload
template< range_return_value re, typename ForwardRange >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng)
{
/// \overload
template< range_return_value re, typename ForwardRange >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange >
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng)
{
/// \overload
template< range_return_value re, typename ForwardRange >
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange& rng, BinaryPredicate pred)
{
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
@ -102,18 +105,21 @@ namespace boost
return range_return<ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
/// \overload
template< range_return_value re, typename ForwardRange, typename BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type
adjacent_find(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng);
}
}
} // namespace range
using range::adjacent_find;
} // namespace boost
#endif // include guard

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

@ -17,27 +17,33 @@
namespace boost
{
/// \brief template function binary_search
///
/// range-based version of the binary_search std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange, class Value>
inline bool binary_search(const ForwardRange& rng, const Value& val)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::binary_search(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template<class ForwardRange, class Value, class BinaryPredicate>
inline bool binary_search(const ForwardRange& rng, const Value& val,
BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
}
/// \brief template function binary_search
///
/// range-based version of the binary_search std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange, class Value>
inline bool binary_search(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template<class ForwardRange, class Value, class BinaryPredicate>
inline bool binary_search(const ForwardRange& rng, const Value& val,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
}
} // namespace range
using range::binary_search;
} // namespace boost
#endif // include guard

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

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

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

@ -17,21 +17,27 @@
namespace boost
{
/// \brief template function copy_backward
///
/// range-based version of the copy_backwards std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept
/// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept
template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator >
inline BidirectionalTraversalWriteableIterator
copy_backward(const BidirectionalRange& rng,
BidirectionalTraversalWriteableIterator out)
namespace range
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
/// \brief template function copy_backward
///
/// range-based version of the copy_backwards std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept
/// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept
template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator >
inline BidirectionalTraversalWriteableIterator
copy_backward(const BidirectionalRange& rng,
BidirectionalTraversalWriteableIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::copy_backward(boost::begin(rng), boost::end(rng), out);
}
}
} // namespace range
using range::copy_backward;
} // namespace boost
#endif // include guard

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

@ -18,27 +18,33 @@
namespace boost
{
/// \brief template function count
///
/// range-based version of the count std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
return std::count(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
count(const SinglePassRange& rng, const Value& val)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function count
///
/// range-based version of the count std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type
count(const SinglePassRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}
} // namespace range
using range::count;
} // namespace boost
#endif // include guard

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

@ -18,28 +18,34 @@
namespace boost
{
/// \brief template function count_if
///
/// range-based version of the count_if std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
count_if(SinglePassRange& rng, UnaryPredicate pred)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
count_if(const SinglePassRange& rng, UnaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function count_if
///
/// range-based version of the count_if std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type
count_if(SinglePassRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type
count_if(const SinglePassRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}
} // namespace range
using range::count_if;
} // namespace boost
#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);
}
}
} // namespace range_detail
namespace range
{
/// \brief template function equal
///
@ -156,12 +159,12 @@ namespace boost
template< class SinglePassRange1, class SinglePassRange2 >
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::equal(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2) );
return ::boost::range_detail::equal(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2) );
}
/// \overload
@ -169,14 +172,17 @@ namespace boost
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
BinaryPredicate pred )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return range_detail::equal(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),
return ::boost::range_detail::equal(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2),
pred);
}
}
} // namespace range
using range::equal;
} // namespace boost
#endif // include guard

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

@ -17,58 +17,64 @@
namespace boost
{
/// \brief template function equal_range
///
/// range-based version of the equal_range std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre SortPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange, class Value>
inline std::pair<
namespace range
{
/// \brief template function equal_range
///
/// range-based version of the equal_range std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre SortPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange, class Value>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
>
equal_range(ForwardRange& rng, const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
equal_range(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template<class ForwardRange, class Value>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
>
equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
}
/// \overload
template<class ForwardRange, class Value>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
>
equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template<class ForwardRange, class Value, class SortPredicate>
inline std::pair<
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
>
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
} // namespace range
using range::equal_range;
} // namespace boost
#endif // include guard

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

@ -17,18 +17,24 @@
namespace boost
{
/// \brief template function fill
///
/// range-based version of the fill std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline ForwardRange& fill(ForwardRange& rng, const Value& val)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function fill
///
/// range-based version of the fill std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline ForwardRange& fill(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::fill(boost::begin(rng), boost::end(rng), val);
return rng;
}
}
} // namespace range
using range::fill;
}
#endif // include guard

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

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

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

@ -18,49 +18,55 @@
namespace boost
{
/// \brief template function find
///
/// range-based version of the find std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find( SinglePassRange& rng, const Value& val )
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function find
///
/// range-based version of the find std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find( SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find( const SinglePassRange& rng, const Value& val )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
}
/// \overload
template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find( const SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val);
}
}
// range_return overloads
/// \overload
template< range_return_value re, class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find( SinglePassRange& rng, const Value& val )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \overload
template< range_return_value re, class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find( SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find( const SinglePassRange& rng, const Value& val )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
}
/// \overload
template< range_return_value re, class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find( const SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val),
rng);
}
}
} // namespace range
using range::find;
}
#endif // include guard

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

@ -18,119 +18,125 @@
namespace boost
{
/// \brief template function find_end
///
/// range-based version of the find_end std algorithm
///
/// \pre ForwardRange1 is a model of the ForwardRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \brief template function find_end
///
/// range-based version of the find_end std algorithm
///
/// \pre ForwardRange1 is a model of the ForwardRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
}
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
find_end(ForwardRange1 const & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
find_end(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
} // namespace range
using range::find_end;
} // namespace boost
#endif // include guard

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

@ -18,122 +18,127 @@
namespace boost
{
/// \brief template function find_first_of
///
/// range-based version of the find_first_of std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \brief template function find_first_of
///
/// range-based version of the find_first_of std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
}
/// \overload
template< class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(SinglePassRange1 const & rng1, ForwardRange2 const & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
}
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type
find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
}
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
/// \overload
template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
}
// range return overloads
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2)),
rng1);
}
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred),
rng1);
}
}
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
/// \overload
template< range_return_value re, class SinglePassRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type
find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange2> ));
return range_return<const SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),pred),
rng1);
}
}
} // namespace range
using range::find_first_of;
} // namespace boost
#endif // include guard

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

@ -18,52 +18,56 @@
namespace boost
{
/// \brief template function find_if
///
/// range-based version of the find_if std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function find_if
///
/// range-based version of the find_if std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
}
/// \overload
template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred);
}
}
// range_return overloads
/// \overload
template< range_return_value re, class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \overload
template< range_return_value re, class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< range_return_value re, class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
}
/// \overload
template< range_return_value re, class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type
find_if( const SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return range_return<const SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
} // namespace range
using range::find_if;
} // namespace boost
#endif // include guard

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

@ -17,26 +17,32 @@
namespace boost
{
/// \brief template function for_each
///
/// range-based version of the for_each std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryFunction is a model of the UnaryFunctionConcept
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
namespace range
{
boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}
/// \overload
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
{
boost::function_requires< SinglePassRangeConcept< SinglePassRange > >();
/// \brief template function for_each
///
/// range-based version of the for_each std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre UnaryFunction is a model of the UnaryFunctionConcept
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}
}
/// \overload
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}
} // namespace range
using range::for_each;
} // namespace boost
#endif // include guard

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

@ -17,28 +17,33 @@
namespace boost
{
/// \brief template function generate
///
/// range-based version of the generate std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Generator is a model of the UnaryFunctionConcept
template< class ForwardRange, class Generator >
inline ForwardRange& generate( ForwardRange& rng, Generator gen )
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function generate
///
/// range-based version of the generate std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Generator is a model of the UnaryFunctionConcept
template< class ForwardRange, class Generator >
inline ForwardRange& generate( ForwardRange& rng, Generator gen )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen);
return rng;
}
/// \overload
template< class ForwardRange, class Generator >
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
std::generate(boost::begin(rng), boost::end(rng), gen);
return rng;
}
}
/// \overload
template< class ForwardRange, class Generator >
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen);
return rng;
}
} // namespace range
using range::generate;
} // namespace boost
#endif // include guard

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

@ -17,153 +17,162 @@
namespace boost
{
/// \brief template function push_heap
///
/// range-based version of the push_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng)
namespace range
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
/// \brief template function push_heap
///
/// range-based version of the push_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void push_heap(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::push_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function pop_heap
///
/// range-based version of the pop_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void pop_heap(RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::pop_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void pop_heap(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::pop_heap(boost::begin(rng),boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function make_heap
///
/// range-based version of the make_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void make_heap(RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::make_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void make_heap(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::make_heap(boost::begin(rng),boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function sort_heap
///
/// range-based version of the sort_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void sort_heap(RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void sort_heap(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
}
/// \overload
template<class RandomAccessRange>
inline void push_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function pop_heap
///
/// range-based version of the pop_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void pop_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void pop_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng),boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function make_heap
///
/// range-based version of the make_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void make_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void make_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng),boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \brief template function sort_heap
///
/// range-based version of the sort_heap std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void sort_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange>
inline void sort_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
/// \overload
template<class RandomAccessRange, class Compare>
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
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

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

@ -17,52 +17,58 @@
namespace boost
{
/// \brief template function inplace_merge
///
/// range-based version of the inplace_merge std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
namespace range
{
/// \brief template function inplace_merge
///
/// range-based version of the inplace_merge std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
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));
return rng;
}
/// \overload
template<class BidirectionalRange>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng;
}
/// \overload
template<class BidirectionalRange, class BinaryPredicate>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
BinaryPredicate pred)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
/// \overload
template<class BidirectionalRange, class BinaryPredicate>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
BinaryPredicate pred)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
}
/// \overload
template<class BidirectionalRange>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng;
}
/// \overload
template<class BidirectionalRange, class BinaryPredicate>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
/// \overload
template<class BidirectionalRange, class BinaryPredicate>
inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
} // namespace range
using range::inplace_merge;
} // namespace boost
#endif // include guard

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

@ -17,36 +17,42 @@
namespace boost
{
/// \brief template function lexicographic_compare
///
/// range-based version of the lexicographic_compare std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
template<class SinglePassRange1, class SinglePassRange2>
inline bool lexicographical_compare(const SinglePassRange1& rng1,
const SinglePassRange2& rng2)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
/// \brief template function lexicographic_compare
///
/// range-based version of the lexicographic_compare std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
template<class SinglePassRange1, class SinglePassRange2>
inline bool lexicographical_compare(const SinglePassRange1& rng1,
const SinglePassRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class BinaryPredicate>
inline bool lexicographical_compare(const SinglePassRange1& rng1,
inline bool lexicographical_compare(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
}
} // namespace range
using range::lexicographical_compare;
} // namespace boost
#endif // include guard

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

@ -18,82 +18,88 @@
namespace boost
{
/// \brief template function lower_bound
///
/// range-based version of the lower_bound std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val )
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function lower_bound
///
/// range-based version of the lower_bound std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
lower_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
}
} // namespace range
using range::lower_bound;
} // namespace boost
#endif // include guard

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

@ -18,92 +18,98 @@
namespace boost
{
/// \brief template function max_element
///
/// range-based version of the max_element std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function max_element
///
/// range-based version of the max_element std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
}
}
/// \overload
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
}
}
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
}
}
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
}
}
// range_return overloads
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
max_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
} // namespace range
using range::max_element;
} // namespace boost
#endif // include guard

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

@ -17,39 +17,45 @@
namespace boost
{
/// \brief template function merge
///
/// range-based version of the merge std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
///
template<class SinglePassRange1, class SinglePassRange2,
namespace range
{
/// \brief template function merge
///
/// range-based version of the merge std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
///
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator>
inline OutputIterator merge(const SinglePassRange1& rng1,
inline OutputIterator merge(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator, class BinaryPredicate>
inline OutputIterator merge(const SinglePassRange1& rng1,
inline OutputIterator merge(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}
}
} // namespace range
using range::merge;
} // namespace boost
#endif // include guard

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

@ -18,92 +18,98 @@
namespace boost
{
/// \brief template function min_element
///
/// range-based version of the min_element std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function min_element
///
/// range-based version of the min_element std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
}
}
/// \overload
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
}
}
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
}
}
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
}
}
// range_return overloads
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
/// \overload
template<range_return_value re, class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template<range_return_value re, class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
min_element(const ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);
}
} // namespace range
using range::min_element;
} // namespace boost
#endif // include guard

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

@ -57,126 +57,139 @@ namespace boost
return std::pair<SinglePassTraversalReadableIterator1,
SinglePassTraversalReadableIterator2>(first1, first2);
}
}
} // namespace range_detail
/// \brief template function mismatch
///
/// range-based version of the mismatch std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
namespace range
{
/// \brief template function mismatch
///
/// range-based version of the mismatch std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
return range_detail::mismatch_impl(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2 >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2));
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
/// \overload
template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
::boost::begin(rng2), ::boost::end(rng2), pred);
}
} // namespace range
using range::mismatch;
} // namespace boost
#endif // include guard

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

@ -17,48 +17,54 @@
namespace boost
{
/// \brief template function nth_element
///
/// range-based version of the nth_element std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void nth_element(RandomAccessRange& rng,
namespace range
{
/// \brief template function nth_element
///
/// range-based version of the nth_element std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void nth_element(RandomAccessRange& rng,
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));
}
/// \overload
template<class RandomAccessRange>
inline void nth_element(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::nth_element(boost::begin(rng),nth,boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void nth_element(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
}
}
/// \overload
template<class RandomAccessRange>
inline void nth_element(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void nth_element(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
}
} // namespace range
using range::nth_element;
} // namespace boost
#endif // include guard

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

@ -17,49 +17,55 @@
namespace boost
{
/// \brief template function partial_sort
///
/// range-based version of the partial_sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void partial_sort(RandomAccessRange& rng,
namespace range
{
/// \brief template function partial_sort
///
/// range-based version of the partial_sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline void partial_sort(RandomAccessRange& rng,
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));
}
/// \overload
template<class RandomAccessRange>
inline void partial_sort(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void partial_sort(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::partial_sort(boost::begin(rng), middle, boost::end(rng),
sort_pred);
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void partial_sort(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
}
}
/// \overload
template<class RandomAccessRange>
inline void partial_sort(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void partial_sort(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng),
sort_pred);
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline void partial_sort(const RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
}
} // namespace range
using range::partial_sort;
} // namespace boost
#endif // include guard

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

@ -18,17 +18,20 @@
namespace boost
{
/// \brief template function partial_sort_copy
///
/// range-based version of the partial_sort_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<typename SinglePassRange, typename RandomAccessRange>
inline typename range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
namespace range
{
/// \brief template function partial_sort_copy
///
/// range-based version of the partial_sort_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<typename SinglePassRange, typename RandomAccessRange>
inline typename range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
@ -36,15 +39,15 @@ namespace boost
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
}
}
/// \overload
template<typename SinglePassRange, typename RandomAccessRange,
/// \overload
template<typename SinglePassRange, typename RandomAccessRange,
typename BinaryPredicate>
inline typename range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
inline typename range_iterator<RandomAccessRange>::type
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
BinaryPredicate pred)
{
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
@ -52,7 +55,10 @@ namespace boost
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
}
} // namespace range
using range::partial_sort_copy;
} // namespace boost
#endif // include guard

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

@ -18,51 +18,57 @@
namespace boost
{
/// \brief template function partition
///
/// range-based version of the partition std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
partition(ForwardRange& rng, UnaryPredicate pred)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::partition(boost::begin(rng),boost::end(rng),pred);
}
/// \overload
template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function partition
///
/// range-based version of the partition std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred);
}
}
/// \overload
template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred);
}
// range_return overloads
/// \overload
template< range_return_value re, class ForwardRange,
/// \overload
template< range_return_value re, class ForwardRange,
class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return boost::range_return<ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}
/// \overload
template< range_return_value re, class ForwardRange,
class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return boost::range_return<const ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}
}
/// \overload
template< range_return_value re, class ForwardRange,
class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return boost::range_return<const ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}
} // namespace range
using range::partition;
} // namespace boost
#endif // include guard

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

@ -17,101 +17,92 @@
namespace boost
{
/// \brief template function next_permutation
///
/// range-based version of the next_permutation std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline bool next_permutation(BidirectionalRange& rng)
namespace range
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
/// \brief template function next_permutation
///
/// range-based version of the next_permutation std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline bool next_permutation(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool next_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \brief template function prev_permutation
///
/// range-based version of the prev_permutation std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline bool prev_permutation(BidirectionalRange& rng)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
boost::function_requires<
BidirectionalRangeConcept<BidirectionalRange> >();
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
}
/// \overload
template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool next_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \brief template function prev_permutation
///
/// range-based version of the prev_permutation std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre Compare is a model of the BinaryPredicateConcept
template<class BidirectionalRange>
inline bool prev_permutation(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
/// \overload
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
} // namespace range
using range::next_permutation;
using range::prev_permutation;
} // namespace boost
#endif // include guard

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

@ -17,46 +17,52 @@
namespace boost
{
/// \brief template function random_shuffle
///
/// range-based version of the random_shuffle std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Generator is a model of the UnaryFunctionConcept
template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
namespace range
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
/// \brief template function random_shuffle
///
/// range-based version of the random_shuffle std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre Generator is a model of the UnaryFunctionConcept
template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::random_shuffle(boost::begin(rng),boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
/// \overload
template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng),boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
/// \overload
template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
} // namespace range
using range::random_shuffle;
} // namespace boost
#endif // include guard

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

@ -18,53 +18,57 @@
namespace boost
{
/// \brief template function remove
///
/// range-based version of the remove std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
remove(ForwardRange& rng, const Value& val)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::remove(boost::begin(rng),boost::end(rng),val);
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
remove(const ForwardRange& rng, const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function remove
///
/// range-based version of the remove std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
remove(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val);
}
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
remove(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val);
}
// range_return overloads
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove(ForwardRange& rng, const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove(const ForwardRange& rng, const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val),
rng);
}
}
} // namespace range
using range::remove;
} // namespace boost
#endif // include guard

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

@ -17,22 +17,28 @@
namespace boost
{
/// \brief template function remove_copy
///
/// range-based version of the remove_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre OutputIterator is a model of the OutputIteratorConcept
/// \pre Value is a model of the EqualityComparableConcept
/// \pre Objects of type Value can be compared for equality with objects of
/// InputIterator's value type.
template< class SinglePassRange, class OutputIterator, class Value >
inline OutputIterator
remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function remove_copy
///
/// range-based version of the remove_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre OutputIterator is a model of the OutputIteratorConcept
/// \pre Value is a model of the EqualityComparableConcept
/// \pre Objects of type Value can be compared for equality with objects of
/// InputIterator's value type.
template< class SinglePassRange, class OutputIterator, class Value >
inline OutputIterator
remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
}
}
} // namespace range
using range::remove_copy;
} // namespace boost
#endif // include guard

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

@ -18,53 +18,58 @@
namespace boost
{
/// \brief template function remove_if
///
/// range-based version of the remove_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return std::remove_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function remove_if
///
/// range-based version of the remove_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove_if(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template< class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove_if(boost::begin(rng),boost::end(rng),pred);
}
}
// range_return overloads
/// \overload
template< range_return_value re, class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template< range_return_value re, class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
remove_if(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
/// \overload
template< range_return_value re, class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \overload
template< range_return_value re, class ForwardRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
remove_if(const ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
} // namespace range
using range::remove_if;
} // namespace boost
#endif // include guard

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

@ -17,31 +17,37 @@
namespace boost
{
/// \brief template function replace
///
/// range-based version of the replace std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline ForwardRange&
replace(ForwardRange& rng, const Value& what,
const Value& with_what)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng;
}
/// \overload
template< class ForwardRange, class Value >
inline const ForwardRange&
replace(const ForwardRange& rng, const Value& what,
/// \brief template function replace
///
/// range-based version of the replace std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline ForwardRange&
replace(ForwardRange& rng, const Value& what,
const Value& with_what)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng;
}
}
/// \overload
template< class ForwardRange, class Value >
inline const ForwardRange&
replace(const ForwardRange& rng, const Value& what,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng;
}
} // namespace range
using range::replace;
} // namespace boost;
#endif // include guard

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

@ -17,20 +17,26 @@
namespace boost
{
/// \brief template function replace_copy
///
/// range-based version of the replace_copy std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class OutputIterator, class Value >
inline OutputIterator
replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
const Value& with_what)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function replace_copy
///
/// range-based version of the replace_copy std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class OutputIterator, class Value >
inline OutputIterator
replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
what, with_what);
}
}
} // namespace range
using range::replace_copy;
} // namespace boost
#endif // include guard

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

@ -17,24 +17,30 @@
namespace boost
{
/// \brief template function replace_copy_if
///
/// range-based version of the replace_copy_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Predicate is a model of the PredicateConcept
/// \pre Value is convertible to Predicate's argument type
/// \pre Value is Assignable
/// \pre Value is convertible to a type in OutputIterator's set of value types.
template< class ForwardRange, class OutputIterator, class Predicate, class Value >
inline OutputIterator
replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
const Value& with_what)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function replace_copy_if
///
/// range-based version of the replace_copy_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Predicate is a model of the PredicateConcept
/// \pre Value is convertible to Predicate's argument type
/// \pre Value is Assignable
/// \pre Value is convertible to a type in OutputIterator's set of value types.
template< class ForwardRange, class OutputIterator, class Predicate, class Value >
inline OutputIterator
replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
pred, with_what);
}
}
} // namespace range
using range::replace_copy_if;
} // namespace boost
#endif // include guard

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

@ -17,33 +17,38 @@
namespace boost
{
/// \brief template function replace_if
///
/// range-based version of the replace_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class ForwardRange, class UnaryPredicate, class Value >
inline ForwardRange&
namespace range
{
/// \brief template function replace_if
///
/// range-based version of the replace_if std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template< class ForwardRange, class UnaryPredicate, class Value >
inline ForwardRange&
replace_if(ForwardRange& rng, UnaryPredicate pred,
const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng;
}
/// \overload
template< class ForwardRange, class UnaryPredicate, class Value >
inline const ForwardRange&
replace_if(const ForwardRange& rng, UnaryPredicate pred,
const Value& val)
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng;
}
}
/// \overload
template< class ForwardRange, class UnaryPredicate, class Value >
inline const ForwardRange&
replace_if(const ForwardRange& rng, UnaryPredicate pred,
const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng;
}
} // namespace range
using range::replace_if;
} // namespace boost
#endif // include guard

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

@ -18,27 +18,33 @@
namespace boost
{
/// \brief template function reverse
///
/// range-based version of the reverse std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
template<class BidirectionalRange>
inline BidirectionalRange& reverse(BidirectionalRange& rng)
namespace range
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
std::reverse(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class BidirectionalRange>
inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
/// \brief template function reverse
///
/// range-based version of the reverse std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
template<class BidirectionalRange>
inline BidirectionalRange& reverse(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng));
return rng;
}
}
/// \overload
template<class BidirectionalRange>
inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng));
return rng;
}
} // namespace range
using range::reverse;
} // namespace boost
#endif // include guard

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

@ -18,25 +18,31 @@
namespace boost
{
/// \brief template function reverse_copy
///
/// range-based version of the reverse_copy std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
namespace range
{
BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}
/// \overload
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT((BidirectionalRangeConcept<BidirectionalRange>));
/// \brief template function reverse_copy
///
/// range-based version of the reverse_copy std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}
}
/// \overload
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}
} // namespace range
using range::reverse_copy;
} // namespace boost
#endif // include guard

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

@ -17,30 +17,36 @@
namespace boost
{
/// \brief template function rotate
///
/// range-based version of the rotate std algorithm
///
/// \pre Rng meets the requirements for a Forward range
template<typename ForwardRange>
inline ForwardRange& rotate(ForwardRange& rng,
typename range_iterator<ForwardRange>::type middle)
namespace range
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng;
}
/// \overload
template<typename ForwardRange>
inline const ForwardRange&
rotate(const ForwardRange& rng,
typename range_iterator<const ForwardRange>::type middle)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
/// \brief template function rotate
///
/// range-based version of the rotate std algorithm
///
/// \pre Rng meets the requirements for a Forward range
template<typename ForwardRange>
inline ForwardRange& rotate(ForwardRange& rng,
typename range_iterator<ForwardRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng;
}
}
/// \overload
template<typename ForwardRange>
inline const ForwardRange&
rotate(const ForwardRange& rng,
typename range_iterator<const ForwardRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng;
}
} // namespace range
using range::rotate;
} // namespace boost
#endif // include guard

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

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

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

@ -18,114 +18,119 @@
namespace boost
{
/// \brief template function search
///
/// range-based version of the search std algorithm
///
/// \pre ForwardRange1 is a model of the ForwardRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \brief template function search
///
/// range-based version of the search std algorithm
///
/// \pre ForwardRange1 is a model of the ForwardRangeConcept
/// \pre ForwardRange2 is a model of the ForwardRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
}
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
}
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
/// \overload
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
}
// range_return overloads
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< ForwardRangeConcept<ForwardRange1> >();
boost::function_requires< ForwardRangeConcept<ForwardRange2> >();
return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred),
rng1);
}
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2)),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type
search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred),
rng1);
}
/// \overload
template< range_return_value re, class ForwardRange1, class ForwardRange2,
class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<const ForwardRange1,re>::
pack(std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred),
rng1);
}
} // namespace range
using range::search;
} // namespace boost
#endif // include guard

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

@ -19,95 +19,98 @@
namespace boost
{
/// \brief template function search
///
/// range-based version of the search std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Integer is an integral type
/// \pre Value is a model of the EqualityComparableConcept
/// \pre ForwardRange's value type is a model of the EqualityComparableConcept
/// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
template< typename ForwardRange, typename Integer, typename Value >
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
namespace range
{
/// \brief template function search
///
/// range-based version of the search std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
/// \pre Integer is an integral type
/// \pre Value is a model of the EqualityComparableConcept
/// \pre ForwardRange's value type is a model of the EqualityComparableConcept
/// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
template< typename ForwardRange, typename Integer, typename Value >
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::search_n(boost::begin(rng),boost::end(rng), count, value);
}
}
/// \overload
template< typename ForwardRange, typename Integer, typename Value >
inline typename range_iterator<const ForwardRange>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
/// \overload
template< typename ForwardRange, typename Integer, typename Value >
inline typename range_iterator<const ForwardRange>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::search_n(boost::begin(rng), boost::end(rng), count, value);
}
}
/// \overload
template< typename ForwardRange, typename Integer, class Value,
/// \overload
template< typename ForwardRange, typename Integer, class Value,
typename BinaryPredicate >
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value,
inline typename range_iterator<ForwardRange>::type
search_n(ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate binary_pred)
{
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type, const Value&>));
return std::search_n(boost::begin(rng), boost::end(rng),
count, value, binary_pred);
}
}
/// \overload
template< typename ForwardRange, typename Integer, typename Value,
/// \overload
template< typename ForwardRange, typename Integer, typename Value,
typename BinaryPredicate >
inline typename range_iterator<const ForwardRange>::type
search_n(const ForwardRange& rng, Integer count, const Value& value,
inline typename range_iterator<const ForwardRange>::type
search_n(const ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate binary_pred)
{
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type, const Value&>));
return std::search_n(boost::begin(rng), boost::end(rng),
count, value, binary_pred);
}
}
// range_return overloads
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
typename Value >
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<ForwardRange,re>::
pack(std::search_n(boost::begin(rng),boost::end(rng),
count, value),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
class Value >
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
typename Value, typename BinaryPredicate >
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value,
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate pred)
{
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
@ -116,15 +119,15 @@ namespace boost
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value, pred),
rng);
}
}
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
/// \overload
template< range_return_value re, typename ForwardRange, typename Integer,
typename Value, typename BinaryPredicate >
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value,
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value,
BinaryPredicate pred)
{
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type,
@ -133,8 +136,10 @@ namespace boost
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value, pred),
rng);
}
}
} // namespace range
using range::search_n;
} // namespace boost
#endif // include guard

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

@ -17,172 +17,182 @@
namespace boost
{
/// \brief template function includes
///
/// range-based version of the includes std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2>
inline bool includes(const SinglePassRange1& rng1,
const SinglePassRange2& rng2)
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
/// \brief template function includes
///
/// range-based version of the includes std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2>
inline bool includes(const SinglePassRange1& rng1,
const SinglePassRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class BinaryPredicate>
inline bool includes(const SinglePassRange1& rng1,
inline bool includes(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
}
/// \brief template function set_union
///
/// range-based version of the set_union std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
/// \brief template function set_union
///
/// range-based version of the set_union std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator>
inline OutputIterator set_union(const SinglePassRange1& rng1,
inline OutputIterator set_union(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator, class BinaryPredicate>
inline OutputIterator set_union(const SinglePassRange1& rng1,
inline OutputIterator set_union(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}
}
/// \brief template function set_intersection
///
/// range-based version of the set_intersection std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
/// \brief template function set_intersection
///
/// range-based version of the set_intersection std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator>
inline OutputIterator set_intersection(const SinglePassRange1& rng1,
inline OutputIterator set_intersection(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator, class BinaryPredicate>
inline OutputIterator set_intersection(const SinglePassRange1& rng1,
inline OutputIterator set_intersection(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),
out, pred);
}
}
/// \brief template function set_difference
///
/// range-based version of the set_difference std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
/// \brief template function set_difference
///
/// range-based version of the set_difference std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator>
inline OutputIterator set_difference(const SinglePassRange1& rng1,
inline OutputIterator set_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator, class BinaryPredicate>
inline OutputIterator set_difference(const SinglePassRange1& rng1,
inline OutputIterator set_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}
}
/// \brief template function set_symmetric_difference
///
/// range-based version of the set_symmetric_difference std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
/// \brief template function set_symmetric_difference
///
/// range-based version of the set_symmetric_difference std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator>
inline OutputIterator
set_symmetric_difference(const SinglePassRange1& rng1,
inline OutputIterator
set_symmetric_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
}
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
/// \overload
template<class SinglePassRange1, class SinglePassRange2,
class OutputIterator, class BinaryPredicate>
inline OutputIterator
set_symmetric_difference(const SinglePassRange1& rng1,
inline OutputIterator
set_symmetric_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out,
BinaryPredicate pred)
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}
}
} // namespace range
using range::includes;
using range::set_union;
using range::set_intersection;
using range::set_difference;
using range::set_symmetric_difference;
} // namespace boost
#endif // include guard

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

@ -17,47 +17,52 @@
namespace boost
{
/// \brief template function sort
///
/// range-based version of the sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline RandomAccessRange& sort(RandomAccessRange& rng)
namespace range
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
/// \brief template function sort
///
/// range-based version of the sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline RandomAccessRange& sort(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& sort(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort(boost::begin(rng),boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& sort(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng),boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}
} // namespace range
using range::sort;
} // namespace boost
#endif // include guard

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

@ -18,51 +18,56 @@
namespace boost
{
/// \brief template function stable_partition
///
/// range-based version of the stable_partition std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template<class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
namespace range
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template<class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
/// \brief template function stable_partition
///
/// range-based version of the stable_partition std algorithm
///
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
/// \pre UnaryPredicate is a model of the UnaryPredicateConcept
template<class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
}
/// \overload
template<class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
}
}
// range_return overloads
template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return range_return<BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng), boost::end(rng), pred),
rng);
}
}
/// \overload
template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
boost::function_requires< BidirectionalRangeConcept<BidirectionalRange> >();
/// \overload
template<range_return_value re, class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type
stable_partition(const BidirectionalRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return range_return<const BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng),boost::end(rng),pred),
rng);
}
}
} // namespace range
using range::stable_partition;
} // namespace boost
#endif // include guard

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

@ -17,46 +17,52 @@
namespace boost
{
/// \brief template function stable_sort
///
/// range-based version of the stable_sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
namespace range
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
/// \brief template function stable_sort
///
/// range-based version of the stable_sort std algorithm
///
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template<class RandomAccessRange>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::stable_sort(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
{
boost::function_requires< RandomAccessRangeConcept<RandomAccessRange> >();
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}
}
/// \overload
template<class RandomAccessRange>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng));
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}
/// \overload
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}
} // namespace range
using range::stable_sort;
} // namespace boost
#endif // include guard

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

@ -57,16 +57,19 @@ namespace boost
}
} // namespace range_detail
/// \brief template function swap_ranges
///
/// range-based version of the swap_ranges std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
template< typename SinglePassRange1, typename SinglePassRange2 >
inline SinglePassRange2&
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
namespace range
{
/// \brief template function swap_ranges
///
/// range-based version of the swap_ranges std algorithm
///
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
template< typename SinglePassRange1, typename SinglePassRange2 >
inline SinglePassRange2&
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
@ -75,7 +78,10 @@ namespace boost
boost::begin(range2), boost::end(range2));
return range2;
}
}
} // namespace range
using range::swap_ranges;
} // namespace boost
#endif // include guard

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

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

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

@ -18,84 +18,90 @@
namespace boost
{
/// \brief template function unique
///
/// range-based version of the unique std algorithm
///
/// \pre Rng meets the requirements for a Forward range
template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng )
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function unique
///
/// range-based version of the unique std algorithm
///
/// \pre Rng meets the requirements for a Forward range
template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
}
/// \overload
template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
}
/// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return range_return<const ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return boost::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
unique( const ForwardRange& rng )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return boost::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return boost::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
return boost::unique<return_begin_found>(rng, pred);
}
}
/// \overload
template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
}
/// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
}
/// \overload
template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type
unique( const ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng, BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
template< class ForwardRange, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
unique( const ForwardRange& rng, BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng, pred);
}
} // namespace range
using range::unique;
} // namespace boost
#endif // include guard

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

@ -17,29 +17,35 @@
namespace boost
{
/// \brief template function unique_copy
///
/// range-based version of the unique_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre OutputIterator is a model of the OutputIteratorConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange, class OutputIterator >
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it )
namespace range
{
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
/// \brief template function unique_copy
///
/// range-based version of the unique_copy std algorithm
///
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
/// \pre OutputIterator is a model of the OutputIteratorConcept
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
template< class SinglePassRange, class OutputIterator >
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
}
/// \overload
template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it,
}
/// \overload
template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it,
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);
}
}
} // namespace range
using range::unique_copy;
} // namespace boost
#endif // include guard

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

@ -18,84 +18,90 @@
namespace boost
{
/// \brief template function upper_bound
///
/// range-based version of the upper_bound std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val )
namespace range
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
/// \brief template function upper_bound
///
/// range-based version of the upper_bound std algorithm
///
/// \pre ForwardRange is a model of the ForwardRangeConcept
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< class ForwardRange, class Value, class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
}
/// \overload
template< range_return_value re, class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
}
/// \overload
template< range_return_value re, class ForwardRange, class Value,
class SortPredicate >
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
boost::function_requires< ForwardRangeConcept<ForwardRange> >();
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
upper_bound( const ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);
}
}
} // namespace range
using range::upper_bound;
} // namespace boost
#endif // include guard