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 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);

8
include/boost/range/algorithm_ext/is_sorted.hpp
View File

@ -47,8 +47,8 @@ namespace boost
template<typename SinglePassRange>
inline bool is_sorted(const SinglePassRange& rng)
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<typename range_value<SinglePassRange>::type>));
return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
}
@ -56,8 +56,8 @@ namespace boost
template<typename SinglePassRange, typename BinaryPredicate>
inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
{
BOOST_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<SinglePassRange>::type, typename range_value<SinglePassRange>::type>));
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange>));
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<SinglePassRange>::type, typename range_value<SinglePassRange>::type>));
return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
}
}

80
include/boost/range/concepts.hpp
View File

@ -60,6 +60,40 @@ namespace boost {
namespace range_detail {
#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
// List broken compiler versions here:
#ifdef __GNUC__
// GNUC 4.2 has strange issues correctly detecting compliance with the Concepts
// hence the least disruptive approach is to turn-off the concept checking for
// this version of the compiler.
#if __GNUC__ == 4 && __GNUC_MINOR__ == 2
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif
#endif
#ifdef __BORLANDC__
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif
#ifdef __PATHCC__
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 0
#endif
// Default to using the concept asserts unless we have defined it off
// during the search for black listed compilers.
#ifndef BOOST_RANGE_ENABLE_CONCEPT_ASSERT
#define BOOST_RANGE_ENABLE_CONCEPT_ASSERT 1
#endif
#endif
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
#define BOOST_RANGE_CONCEPT_ASSERT( x ) BOOST_CONCEPT_ASSERT( x )
#else
#define BOOST_RANGE_CONCEPT_ASSERT( x )
#endif
// Rationale for the inclusion of redefined iterator concept
// classes:
//
@ -77,9 +111,10 @@ namespace boost {
template<class Iterator>
struct IncrementableIteratorConcept : CopyConstructible<Iterator>
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
typedef BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator>::type traversal_category;
BOOST_CONCEPT_ASSERT((
BOOST_RANGE_CONCEPT_ASSERT((
Convertible<
traversal_category,
incrementable_traversal_tag
@ -92,6 +127,7 @@ namespace boost {
}
private:
Iterator i;
#endif
};
template<class Iterator>
@ -99,11 +135,13 @@ namespace boost {
: IncrementableIteratorConcept<Iterator>
, EqualityComparable<Iterator>
{
BOOST_CONCEPT_ASSERT((
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((
Convertible<
BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
single_pass_traversal_tag
>));
#endif
};
template<class Iterator>
@ -111,23 +149,26 @@ namespace boost {
: SinglePassIteratorConcept<Iterator>
, DefaultConstructible<Iterator>
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
typedef BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::difference_type difference_type;
BOOST_MPL_ASSERT((is_integral<difference_type>));
BOOST_MPL_ASSERT_RELATION(std::numeric_limits<difference_type>::is_signed, ==, true);
BOOST_CONCEPT_ASSERT((
BOOST_RANGE_CONCEPT_ASSERT((
Convertible<
BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
forward_traversal_tag
>));
#endif
};
template<class Iterator>
struct BidirectionalIteratorConcept
: ForwardIteratorConcept<Iterator>
{
BOOST_CONCEPT_ASSERT((
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((
Convertible<
BOOST_DEDUCED_TYPENAME BidirectionalIteratorConcept::traversal_category,
bidirectional_traversal_tag
@ -140,13 +181,15 @@ namespace boost {
}
private:
Iterator i;
#endif
};
template<class Iterator>
struct RandomAccessIteratorConcept
: BidirectionalIteratorConcept<Iterator>
{
BOOST_CONCEPT_ASSERT((
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((
Convertible<
BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::traversal_category,
random_access_traversal_tag
@ -165,6 +208,7 @@ namespace boost {
BOOST_DEDUCED_TYPENAME RandomAccessIteratorConcept::difference_type n;
Iterator i;
Iterator j;
#endif
};
} // namespace range_detail
@ -173,11 +217,12 @@ namespace boost {
template<class T>
struct SinglePassRangeConcept
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
typedef BOOST_DEDUCED_TYPENAME range_iterator<T const>::type const_iterator;
typedef BOOST_DEDUCED_TYPENAME range_iterator<T>::type iterator;
BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
BOOST_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<iterator>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::SinglePassIteratorConcept<const_iterator>));
BOOST_CONCEPT_USAGE(SinglePassRangeConcept)
{
@ -208,19 +253,23 @@ namespace boost {
// T to be an abstract class. The other obvious alternative of
// T& produces a warning on some compilers.
T* m_range;
#endif
};
//! Check if a type T models the ForwardRange range concept.
template<class T>
struct ForwardRangeConcept : SinglePassRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::iterator>));
BOOST_RANGE_CONCEPT_ASSERT((range_detail::ForwardIteratorConcept<BOOST_DEDUCED_TYPENAME ForwardRangeConcept::const_iterator>));
#endif
};
template<class Range>
struct WriteableRangeConcept
{
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
typedef BOOST_DEDUCED_TYPENAME range_iterator<Range>::type iterator;
BOOST_CONCEPT_USAGE(WriteableRangeConcept)
@ -230,6 +279,7 @@ namespace boost {
private:
iterator i;
BOOST_DEDUCED_TYPENAME range_value<Range>::type v;
#endif
};
//! Check if a type T models the WriteableForwardRange range concept.
@ -244,8 +294,10 @@ namespace boost {
template<class T>
struct BidirectionalRangeConcept : ForwardRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::iterator>));
BOOST_RANGE_CONCEPT_ASSERT((BidirectionalIteratorConcept<BOOST_DEDUCED_TYPENAME BidirectionalRangeConcept::const_iterator>));
#endif
};
//! Check if a type T models the WriteableBidirectionalRange range concept.
@ -260,8 +312,10 @@ namespace boost {
template<class T>
struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
{
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
BOOST_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
#if BOOST_RANGE_ENABLE_CONCEPT_ASSERT
BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::iterator>));
BOOST_RANGE_CONCEPT_ASSERT((RandomAccessIteratorConcept<BOOST_DEDUCED_TYPENAME RandomAccessRangeConcept::const_iterator>));
#endif
};
//! Check if a type T models the WriteableRandomAccessRange range concept.

8
include/boost/range/join.hpp
View File

@ -28,8 +28,8 @@ iterator_range<range_detail::join_iterator<
>
join(const SinglePassRange1& r1, const SinglePassRange2& r2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
typedef range_detail::join_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
@ -50,8 +50,8 @@ iterator_range<range_detail::join_iterator<
>
join(SinglePassRange1& r1, SinglePassRange2& r2)
{
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
typedef range_detail::join_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,