feedc0de/boost_range
1
0
Fork 0
forked from boostorg/range
Code Pull Requests Activity

Boost.Range is modified to conditionally compile concept assertions. This has been configured to disable concept assertions in Boost.Range for known broken compilers.

Browse Source 
[SVN r61035]
This commit is contained in:
Neil Groves
2010-04-04 10:47:21 +00:00
parent 71c2ca614c
commit debce93f63
55 changed files with 325 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -32,7 +32,7 @@ template< typename ForwardRange >
inline typename range_iterator<ForwardRange>::type
adjacent_find(ForwardRange & rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::adjacent_find(boost::begin(rng),boost::end(rng));
}
@ -41,7 +41,7 @@ template< typename ForwardRange >
inline typename range_iterator<const ForwardRange>::type
adjacent_find(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::adjacent_find(boost::begin(rng),boost::end(rng));
}
@ -50,8 +50,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_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);
@ -62,8 +62,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_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);
@ -76,7 +76,7 @@ template< range_return_value re, typename ForwardRange >
inline typename range_return<ForwardRange,re>::type
adjacent_find(ForwardRange & rng)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
rng);
@ -87,7 +87,7 @@ 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>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng)),
rng);
@ -98,8 +98,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
typename range_value<ForwardRange>::type>));
return range_return<ForwardRange,re>::
@ -112,7 +112,7 @@ 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>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred),
rng);

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

@ -29,7 +29,7 @@ namespace boost
template<class ForwardRange, class Value>
inline bool binary_search(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val);
}
@ -38,7 +38,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::binary_search(boost::begin(rng), boost::end(rng), val, pred);
}

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

@ -30,7 +30,7 @@ namespace boost
template< class SinglePassRange, class OutputIterator >
inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::copy(boost::begin(rng),boost::end(rng),out);
}

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

@ -32,7 +32,7 @@ inline BidirectionalTraversalWriteableIterator
copy_backward(const BidirectionalRange& rng,
BidirectionalTraversalWriteableIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::copy_backward(boost::begin(rng), boost::end(rng), out);
}

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

@ -30,7 +30,7 @@ template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
count(SinglePassRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count(boost::begin(rng), boost::end(rng), val);
}

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

@ -31,7 +31,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}
@ -40,7 +40,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::count_if(boost::begin(rng), boost::end(rng), pred);
}

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

@ -159,8 +159,8 @@ namespace boost
template< class SinglePassRange1, class SinglePassRange2 >
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::equal(
::boost::begin(rng1), ::boost::end(rng1),
@ -172,8 +172,8 @@ namespace boost
inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::equal(
::boost::begin(rng1), ::boost::end(rng1),

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

@ -33,7 +33,7 @@ inline std::pair<
>
equal_range(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
@ -45,7 +45,7 @@ inline std::pair<
>
equal_range(const ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val);
}
@ -57,7 +57,7 @@ inline std::pair<
>
equal_range(ForwardRange& rng, const Value& val, SortPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}
@ -69,7 +69,7 @@ inline std::pair<
>
equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::equal_range(boost::begin(rng), boost::end(rng), val, pred);
}

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

@ -28,7 +28,7 @@ namespace boost
template< class ForwardRange, class Value >
inline ForwardRange& fill(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::fill(boost::begin(rng), boost::end(rng), val);
return rng;
}

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

@ -29,7 +29,7 @@ namespace boost
template< class ForwardRange, class Size, class Value >
inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_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;

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

@ -30,7 +30,7 @@ template< class SinglePassRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find( SinglePassRange& rng, const Value& val )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find(boost::begin(rng), boost::end(rng), val);
}
@ -41,7 +41,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>::
pack(std::find(boost::begin(rng), boost::end(rng), val),
rng);

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

@ -32,8 +32,8 @@ template< class ForwardRange1, class ForwardRange2 >
inline BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
@ -44,8 +44,8 @@ template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type
find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_end(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
@ -56,8 +56,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),
@ -71,8 +71,8 @@ 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, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<ForwardRange1,re>::
pack(std::find_end(boost::begin(rng1), boost::end(rng1),

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

@ -32,8 +32,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
@ -44,8 +44,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::find_first_of(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
@ -57,8 +57,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),
@ -73,8 +73,8 @@ inline BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type
find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return range_return<SinglePassRange1,re>::
pack(std::find_first_of(boost::begin(rng1), boost::end(rng1),

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

@ -31,7 +31,7 @@ template< class SinglePassRange, class UnaryPredicate >
inline BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type
find_if( SinglePassRange& rng, UnaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::find_if(boost::begin(rng), boost::end(rng), pred);
}
@ -42,7 +42,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return range_return<SinglePassRange,re>::
pack(std::find_if(boost::begin(rng), boost::end(rng), pred),
rng);

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

@ -29,7 +29,7 @@ namespace boost
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}
@ -37,7 +37,7 @@ inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
template< class SinglePassRange, class UnaryFunction >
inline UnaryFunction for_each(SinglePassRange const & rng, UnaryFunction fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::for_each(boost::begin(rng),boost::end(rng),fun);
}

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

@ -28,7 +28,7 @@ namespace boost
template< class ForwardRange, class Generator >
inline ForwardRange& generate( ForwardRange& rng, Generator gen )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen);
return rng;
}
@ -37,7 +37,7 @@ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
template< class ForwardRange, class Generator >
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::generate(boost::begin(rng), boost::end(rng), gen);
return rng;
}

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

@ -29,7 +29,7 @@ namespace boost
template<class RandomAccessRange>
inline void push_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng));
}
@ -37,7 +37,7 @@ inline void push_heap(RandomAccessRange& rng)
template<class RandomAccessRange>
inline void push_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng));
}
@ -45,7 +45,7 @@ inline void push_heap(const RandomAccessRange& rng)
template<class RandomAccessRange, class Compare>
inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -53,7 +53,7 @@ inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange, class Compare>
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -66,7 +66,7 @@ inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange>
inline void pop_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng));
}
@ -74,7 +74,7 @@ inline void pop_heap(RandomAccessRange& rng)
template<class RandomAccessRange>
inline void pop_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng),boost::end(rng));
}
@ -82,7 +82,7 @@ inline void pop_heap(const RandomAccessRange& rng)
template<class RandomAccessRange, class Compare>
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -90,7 +90,7 @@ inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange, class Compare>
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -103,7 +103,7 @@ inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange>
inline void make_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng));
}
@ -111,7 +111,7 @@ inline void make_heap(RandomAccessRange& rng)
template<class RandomAccessRange>
inline void make_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng),boost::end(rng));
}
@ -119,7 +119,7 @@ inline void make_heap(const RandomAccessRange& rng)
template<class RandomAccessRange, class Compare>
inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -127,7 +127,7 @@ inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange, class Compare>
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -140,7 +140,7 @@ inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange>
inline void sort_heap(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng));
}
@ -148,7 +148,7 @@ inline void sort_heap(RandomAccessRange& rng)
template<class RandomAccessRange>
inline void sort_heap(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng));
}
@ -156,7 +156,7 @@ inline void sort_heap(const RandomAccessRange& rng)
template<class RandomAccessRange, class Compare>
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}
@ -164,7 +164,7 @@ inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
template<class RandomAccessRange, class Compare>
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
}

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

@ -30,7 +30,7 @@ template<class BidirectionalRange>
inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng;
}
@ -40,7 +40,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng));
return rng;
}
@ -51,7 +51,7 @@ inline BidirectionalRange& inplace_merge(BidirectionalRange& rng,
BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}
@ -62,7 +62,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred);
return rng;
}

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

@ -30,8 +30,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
@ -44,8 +44,8 @@ inline bool lexicographical_compare(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::lexicographical_compare(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);

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

@ -30,7 +30,7 @@ template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
lower_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
@ -38,7 +38,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
@ -46,7 +46,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val),
rng);
@ -56,7 +56,7 @@ template< range_return_value re, class ForwardRange, class Value, class SortPred
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
lower_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);

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

@ -31,7 +31,7 @@ template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
}
@ -40,7 +40,7 @@ template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
max_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng));
}
@ -49,7 +49,7 @@ template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
max_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
}
@ -58,7 +58,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::max_element(boost::begin(rng), boost::end(rng), pred);
}
@ -69,7 +69,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
rng);
@ -80,7 +80,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng)),
rng);
@ -91,7 +91,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);
@ -102,7 +102,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::max_element(boost::begin(rng), boost::end(rng), pred),
rng);

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

@ -34,8 +34,8 @@ inline OutputIterator merge(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
@ -48,8 +48,8 @@ inline OutputIterator merge(const SinglePassRange1& rng1,
OutputIterator out,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::merge(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}

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

@ -31,7 +31,7 @@ template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
}
@ -40,7 +40,7 @@ template<class ForwardRange>
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
min_element(const ForwardRange& rng)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng));
}
@ -49,7 +49,7 @@ template<class ForwardRange, class BinaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
min_element(ForwardRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
}
@ -58,7 +58,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::min_element(boost::begin(rng), boost::end(rng), pred);
}
@ -69,7 +69,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
rng);
@ -80,7 +80,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng)),
rng);
@ -91,7 +91,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);
@ -102,7 +102,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::min_element(boost::begin(rng), boost::end(rng), pred),
rng);

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

@ -74,8 +74,8 @@ inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -89,8 +89,8 @@ inline std::pair<
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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -104,8 +104,8 @@ inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -119,8 +119,8 @@ inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -135,8 +135,8 @@ inline std::pair<
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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -150,8 +150,8 @@ inline std::pair<
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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -165,8 +165,8 @@ inline std::pair<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type >
mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),
@ -180,8 +180,8 @@ inline std::pair<
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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
return ::boost::range_detail::mismatch_impl(
::boost::begin(rng1), ::boost::end(rng1),

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

@ -30,7 +30,7 @@ template<class RandomAccessRange>
inline void nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::nth_element(boost::begin(rng), nth, boost::end(rng));
}
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng));
}
@ -49,7 +49,7 @@ inline void nth_element(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
}
@ -59,7 +59,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
}

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

@ -30,7 +30,7 @@ template<class RandomAccessRange>
inline void partial_sort(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
}
@ -49,7 +49,7 @@ inline void partial_sort(RandomAccessRange& rng,
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng),
sort_pred);
}
@ -60,7 +60,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
}

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

@ -32,10 +32,10 @@ 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>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2));
@ -48,10 +48,10 @@ 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>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((WriteableRandomAccessRangeConcept<RandomAccessRange>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SameTypeConcept<typename range_value<SinglePassRange>::type, typename range_value<RandomAccessRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<RandomAccessRange>::type, typename range_value<RandomAccessRange>::type>));
return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);

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

@ -30,7 +30,7 @@ template<class ForwardRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred);
}
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::partition(boost::begin(rng),boost::end(rng),pred);
}
@ -51,7 +51,7 @@ template< range_return_value re, class ForwardRange,
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
partition(ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return boost::range_return<ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}
@ -62,7 +62,7 @@ template< range_return_value re, class ForwardRange,
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
partition(const ForwardRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return boost::range_return<const ForwardRange,re>::
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
}

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

@ -29,7 +29,7 @@ namespace boost
template<class BidirectionalRange>
inline bool next_permutation(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
@ -37,7 +37,7 @@ inline bool next_permutation(BidirectionalRange& rng)
template<class BidirectionalRange>
inline bool next_permutation(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng));
}
@ -45,7 +45,7 @@ inline bool next_permutation(const BidirectionalRange& rng)
template<class BidirectionalRange, class Compare>
inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
@ -55,7 +55,7 @@ template<class BidirectionalRange, class Compare>
inline bool next_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::next_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
@ -69,7 +69,7 @@ inline bool next_permutation(const BidirectionalRange& rng,
template<class BidirectionalRange>
inline bool prev_permutation(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
@ -77,7 +77,7 @@ inline bool prev_permutation(BidirectionalRange& rng)
template<class BidirectionalRange>
inline bool prev_permutation(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng));
}
@ -85,7 +85,7 @@ inline bool prev_permutation(const BidirectionalRange& rng)
template<class BidirectionalRange, class Compare>
inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}
@ -95,7 +95,7 @@ template<class BidirectionalRange, class Compare>
inline bool prev_permutation(const BidirectionalRange& rng,
Compare comp_pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::prev_permutation(boost::begin(rng), boost::end(rng),
comp_pred);
}

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

@ -29,7 +29,7 @@ namespace boost
template<class RandomAccessRange>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng));
return rng;
}
@ -38,7 +38,7 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
template<class RandomAccessRange>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng),boost::end(rng));
return rng;
}
@ -47,7 +47,7 @@ inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
template<class RandomAccessRange, class Generator>
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}
@ -56,7 +56,7 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
template<class RandomAccessRange, class Generator>
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
return rng;
}

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

@ -30,7 +30,7 @@ template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
remove(ForwardRange& rng, const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val);
}
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove(boost::begin(rng),boost::end(rng),val);
}
@ -50,7 +50,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val),
rng);
@ -61,7 +61,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::remove(boost::begin(rng), boost::end(rng), val),
rng);

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

@ -33,7 +33,7 @@ template< class SinglePassRange, class OutputIterator, class Value >
inline OutputIterator
remove_copy(SinglePassRange& rng, OutputIterator out_it, const Value& val)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val);
}

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

@ -31,7 +31,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::remove_if(boost::begin(rng), boost::end(rng), pred);
}
@ -40,7 +40,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::remove_if(boost::begin(rng),boost::end(rng),pred);
}
@ -51,7 +51,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng);
@ -62,7 +62,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::pack(
std::remove_if(boost::begin(rng), boost::end(rng), pred),
rng);

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

@ -30,7 +30,7 @@ inline ForwardRange&
replace(ForwardRange& rng, const Value& what,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng;
}
@ -41,7 +41,7 @@ inline const ForwardRange&
replace(const ForwardRange& rng, const Value& what,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
return rng;
}

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

@ -30,7 +30,7 @@ inline OutputIterator
replace_copy(ForwardRange& rng, OutputIterator out_it, const Value& what,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy(boost::begin(rng), boost::end(rng), out_it,
what, with_what);
}

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

@ -34,7 +34,7 @@ inline OutputIterator
replace_copy_if(ForwardRange& rng, OutputIterator out_it, Predicate pred,
const Value& with_what)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it,
pred, with_what);
}

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

@ -31,7 +31,7 @@ inline ForwardRange&
replace_if(ForwardRange& rng, UnaryPredicate pred,
const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng;
}
@ -42,7 +42,7 @@ inline const ForwardRange&
replace_if(const ForwardRange& rng, UnaryPredicate pred,
const Value& val)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
return rng;
}

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

@ -29,7 +29,7 @@ namespace boost
template<class BidirectionalRange>
inline BidirectionalRange& reverse(BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng));
return rng;
}
@ -38,7 +38,7 @@ inline BidirectionalRange& reverse(BidirectionalRange& rng)
template<class BidirectionalRange>
inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
std::reverse(boost::begin(rng), boost::end(rng));
return rng;
}

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

@ -29,7 +29,7 @@ namespace boost
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}
@ -37,7 +37,7 @@ inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
template<typename BidirectionalRange, typename OutputIterator>
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
}

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

@ -29,7 +29,7 @@ template<typename ForwardRange>
inline ForwardRange& rotate(ForwardRange& rng,
typename range_iterator<ForwardRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng;
}
@ -40,7 +40,7 @@ inline const ForwardRange&
rotate(const ForwardRange& rng,
typename range_iterator<const ForwardRange>::type middle)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
std::rotate(boost::begin(rng), middle, boost::end(rng));
return rng;
}

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

@ -33,7 +33,7 @@ namespace boost
OutputIterator target
)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target);
}

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

@ -32,8 +32,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
@ -43,8 +43,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
@ -54,8 +54,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
@ -66,8 +66,8 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
return std::search(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2),pred);
}
@ -79,8 +79,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_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)),
@ -92,8 +92,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_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)),
@ -106,8 +106,8 @@ template< range_return_value re, class ForwardRange1, class ForwardRange2,
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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> ));
BOOST_RANGE_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),
@ -121,8 +121,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
BOOST_RANGE_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),

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

@ -35,7 +35,7 @@ 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>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::search_n(boost::begin(rng),boost::end(rng), count, value);
}
@ -44,7 +44,7 @@ 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>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return std::search_n(boost::begin(rng), boost::end(rng), count, value);
}
@ -55,8 +55,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_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);
@ -69,8 +69,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_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);
@ -84,7 +84,7 @@ template< range_return_value re, typename ForwardRange, typename Integer,
inline typename range_return<ForwardRange,re>::type
search_n(ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<ForwardRange,re>::
pack(std::search_n(boost::begin(rng),boost::end(rng),
count, value),
@ -97,7 +97,7 @@ template< range_return_value re, typename ForwardRange, typename Integer,
inline typename range_return<const ForwardRange,re>::type
search_n(const ForwardRange& rng, Integer count, const Value& value)
{
BOOST_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_return<const ForwardRange,re>::
pack(std::search_n(boost::begin(rng), boost::end(rng),
count, value),
@ -111,8 +111,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<ForwardRange>::type,
const Value&>));
return range_return<ForwardRange,re>::
@ -128,8 +128,8 @@ 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,
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
typename range_value<const ForwardRange>::type,
const Value&>));
return range_return<const ForwardRange,re>::

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

@ -31,8 +31,8 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1),boost::end(rng1),
boost::begin(rng2),boost::end(rng2));
}
@ -44,8 +44,8 @@ inline bool includes(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::includes(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), pred);
}
@ -63,8 +63,8 @@ inline OutputIterator set_union(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
@ -77,8 +77,8 @@ inline OutputIterator set_union(const SinglePassRange1& rng1,
OutputIterator out,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_union(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
}
@ -96,8 +96,8 @@ inline OutputIterator set_intersection(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
@ -110,8 +110,8 @@ inline OutputIterator set_intersection(const SinglePassRange1& rng1,
OutputIterator out,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_intersection(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),
out, pred);
@ -130,8 +130,8 @@ inline OutputIterator set_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
@ -144,8 +144,8 @@ inline OutputIterator set_difference(const SinglePassRange1& rng1,
OutputIterator out,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_difference(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);
@ -165,8 +165,8 @@ set_symmetric_difference(const SinglePassRange1& rng1,
const SinglePassRange2& rng2,
OutputIterator out)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out);
}
@ -180,8 +180,8 @@ set_symmetric_difference(const SinglePassRange1& rng1,
OutputIterator out,
BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return std::set_symmetric_difference(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2), out, pred);

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

@ -29,7 +29,7 @@ namespace boost
template<class RandomAccessRange>
inline RandomAccessRange& sort(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng));
return rng;
}
@ -38,7 +38,7 @@ inline RandomAccessRange& sort(RandomAccessRange& rng)
template<class RandomAccessRange>
inline const RandomAccessRange& sort(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng),boost::end(rng));
return rng;
}
@ -47,7 +47,7 @@ inline const RandomAccessRange& sort(const RandomAccessRange& rng)
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}
@ -56,7 +56,7 @@ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::sort(boost::begin(rng), boost::end(rng), pred);
return rng;
}

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

@ -31,7 +31,7 @@ template<class BidirectionalRange, class UnaryPredicate>
inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type
stable_partition(BidirectionalRange& rng, UnaryPredicate pred)
{
BOOST_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return std::stable_partition(boost::begin(rng), boost::end(rng), pred);
}
@ -40,7 +40,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return std::stable_partition(boost::begin(rng),boost::end(rng),pred);
}
@ -49,7 +49,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
return range_return<BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng), boost::end(rng), pred),
rng);
@ -60,7 +60,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
return range_return<const BidirectionalRange,re>::pack(
std::stable_partition(boost::begin(rng),boost::end(rng),pred),
rng);

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

@ -29,7 +29,7 @@ namespace boost
template<class RandomAccessRange>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng));
return rng;
}
@ -38,7 +38,7 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
template<class RandomAccessRange>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng));
return rng;
}
@ -47,7 +47,7 @@ inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
template<class RandomAccessRange, class BinaryPredicate>
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}
@ -56,7 +56,7 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate so
template<class RandomAccessRange, class BinaryPredicate>
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
{
BOOST_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
return rng;
}

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

@ -70,8 +70,8 @@ template< typename SinglePassRange1, typename SinglePassRange2 >
inline SinglePassRange2&
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>));
boost::range_detail::swap_ranges_impl(
boost::begin(range1), boost::end(range1),

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

@ -38,7 +38,7 @@ namespace boost
OutputIterator out,
UnaryOperation fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
return std::transform(boost::begin(rng),boost::end(rng),out,fun);
}
@ -82,8 +82,8 @@ namespace boost
OutputIterator out,
BinaryOperation fun)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
return range_detail::transform_impl(
boost::begin(rng1), boost::end(rng1),
boost::begin(rng2), boost::end(rng2),

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

@ -30,7 +30,7 @@ template< range_return_value re, class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
unique( ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
@ -41,7 +41,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack( std::unique( boost::begin(rng),
boost::end(rng)), rng );
@ -51,7 +51,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
@ -61,7 +61,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return range_return<const ForwardRange,re>::
pack(std::unique(boost::begin(rng), boost::end(rng), pred),
rng);
@ -72,7 +72,7 @@ template< class ForwardRange >
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type
unique( ForwardRange& rng )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@ -80,7 +80,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@ -88,7 +88,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng);
}
/// \overload
@ -96,7 +96,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
return ::boost::range::unique<return_begin_found>(rng, pred);
}

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

@ -31,7 +31,7 @@ template< class SinglePassRange, class OutputIterator >
inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
}
/// \overload
@ -40,7 +40,7 @@ inline OutputIterator
unique_copy( const SinglePassRange& rng, OutputIterator out_it,
BinaryPredicate pred )
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
}

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

@ -30,7 +30,7 @@ template< class ForwardRange, class Value >
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
upper_bound( ForwardRange& rng, Value val )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val);
}
/// \overload
@ -39,7 +39,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred);
}
/// \overload
@ -47,7 +47,7 @@ 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> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val),
rng);
@ -58,7 +58,7 @@ template< range_return_value re, class ForwardRange, class Value,
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
upper_bound( ForwardRange& rng, Value val, SortPredicate pred )
{
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
return range_return<ForwardRange,re>::
pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred),
rng);