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

Ticket 9851 - adaptors should perform concept check assertions.

Browse Source
This commit is contained in:
Neil Groves
2014-05-06 23:37:21 +01:00
parent d7fde2736c
commit 5f2560f753
52 changed files with 1134 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
include/boost/range/adaptor/adjacent_filtered.hpp
View File

@@ -21,6 +21,7 @@
#include <boost/range/iterator_range.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/next_prior.hpp>
@@ -154,6 +155,8 @@ namespace boost
operator|( ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRng>));
return adjacent_filtered_range<BinPredicate, ForwardRng, true>( f.val, r );
}
@@ -162,6 +165,8 @@ namespace boost
operator|( const ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRng>));
return adjacent_filtered_range<BinPredicate,
const ForwardRng, true>( f.val, r );
}
@@ -171,6 +176,7 @@ namespace boost
operator|( ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRng>));
return adjacent_filtered_range<BinPredicate, ForwardRng, false>( f.val, r );
}
@@ -179,6 +185,7 @@ namespace boost
operator|( const ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRng>));
return adjacent_filtered_range<BinPredicate,
const ForwardRng, false>( f.val, r );
}
@@ -207,6 +214,7 @@ namespace boost
inline adjacent_filtered_range<BinPredicate, ForwardRng, true>
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRng>));
return adjacent_filtered_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
}
@@ -214,6 +222,7 @@ namespace boost
inline adjacent_filtered_range<BinPredicate, const ForwardRng, true>
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRng>));
return adjacent_filtered_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
}

34
include/boost/range/adaptor/copied.hpp
View File

@@ -1,6 +1,6 @@
// Boost.Range library
//
// Copyright Thorsten Ottosen, Neil Groves 2006 - 2008. Use, modification and
// Copyright Thorsten Ottosen, Neil Groves 2006. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
@@ -15,6 +15,7 @@
#include <boost/range/adaptor/sliced.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
namespace boost
{
@@ -29,25 +30,34 @@ namespace boost
std::size_t u;
};
template< class CopyableRandomAccessRng >
inline CopyableRandomAccessRng
operator|( const CopyableRandomAccessRng& r, const copied& f )
template<class CopyableRandomAccessRange>
inline CopyableRandomAccessRange
operator|(const CopyableRandomAccessRange& r, const copied& f)
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<const CopyableRandomAccessRange>));
iterator_range<
BOOST_DEDUCED_TYPENAME range_iterator<const
CopyableRandomAccessRng>::type >
temp( adaptors::slice( r, f.t, f.u ) );
return CopyableRandomAccessRng( temp.begin(), temp.end() );
BOOST_DEDUCED_TYPENAME range_iterator<
const CopyableRandomAccessRange
>::type
> temp(adaptors::slice(r, f.t, f.u));
return CopyableRandomAccessRange(temp.begin(), temp.end());
}
template<class CopyableRandomAccessRange>
inline CopyableRandomAccessRange
copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<const CopyableRandomAccessRange>));
iterator_range<
BOOST_DEDUCED_TYPENAME range_iterator<const
CopyableRandomAccessRange>::type> temp(
adaptors::slice(rng, t, u));
BOOST_DEDUCED_TYPENAME range_iterator<
const CopyableRandomAccessRange
>::type
> temp(adaptors::slice(rng, t, u));
return CopyableRandomAccessRange( temp.begin(), temp.end() );
}
@@ -55,4 +65,4 @@ namespace boost
}
#endif
#endif // include guard

45
include/boost/range/adaptor/filtered.hpp
View File

@@ -13,6 +13,7 @@
#include <boost/range/adaptor/argument_fwd.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/filter_iterator.hpp>
namespace boost
@@ -47,20 +48,23 @@ namespace boost
{ }
};
template< class InputRng, class Predicate >
inline filtered_range<Predicate, InputRng>
operator|( InputRng& r,
const filter_holder<Predicate>& f )
template< class ForwardRange, class Predicate >
inline filtered_range<Predicate, ForwardRange>
operator|(ForwardRange& r,
const filter_holder<Predicate>& f)
{
return filtered_range<Predicate, InputRng>( f.val, r );
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return filtered_range<Predicate, ForwardRange>( f.val, r );
}
template< class InputRng, class Predicate >
inline filtered_range<Predicate, const InputRng>
operator|( const InputRng& r,
const filter_holder<Predicate>& f )
template< class ForwardRange, class Predicate >
inline filtered_range<Predicate, const ForwardRange>
operator|(const ForwardRange& r,
const filter_holder<Predicate>& f )
{
return filtered_range<Predicate, const InputRng>( f.val, r );
BOOST_RANGE_CONCEPT_ASSERT((
ForwardRangeConcept<const ForwardRange>));
return filtered_range<Predicate, const ForwardRange>( f.val, r );
}
} // 'range_detail'
@@ -81,18 +85,23 @@ namespace boost
range_detail::forwarder<range_detail::filter_holder>();
}
template<class InputRange, class Predicate>
inline filtered_range<Predicate, InputRange>
filter(InputRange& rng, Predicate filter_pred)
template<class ForwardRange, class Predicate>
inline filtered_range<Predicate, ForwardRange>
filter(ForwardRange& rng, Predicate filter_pred)
{
return range_detail::filtered_range<Predicate, InputRange>( filter_pred, rng );
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return range_detail::filtered_range<Predicate, ForwardRange>( filter_pred, rng );
}
template<class InputRange, class Predicate>
inline filtered_range<Predicate, const InputRange>
filter(const InputRange& rng, Predicate filter_pred)
template<class ForwardRange, class Predicate>
inline filtered_range<Predicate, const ForwardRange>
filter(const ForwardRange& rng, Predicate filter_pred)
{
return range_detail::filtered_range<Predicate, const InputRange>( filter_pred, rng );
BOOST_RANGE_CONCEPT_ASSERT((
ForwardRangeConcept<const ForwardRange>));
return range_detail::filtered_range<Predicate, const ForwardRange>( filter_pred, rng );
}
} // 'adaptors'

13
include/boost/range/adaptor/indexed.hpp
View File

@@ -21,6 +21,7 @@
#include <boost/range/iterator_range.hpp>
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
@@ -124,6 +125,9 @@ namespace boost
operator|( SinglePassRange& r,
const indexed& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return indexed_range<SinglePassRange>( f.val, r );
}
@@ -132,6 +136,9 @@ namespace boost
operator|( const SinglePassRange& r,
const indexed& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return indexed_range<const SinglePassRange>( f.val, r );
}
@@ -139,6 +146,9 @@ namespace boost
inline indexed_range<SinglePassRange>
index(SinglePassRange& rng, Index index_value)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return indexed_range<SinglePassRange>(index_value, rng);
}
@@ -146,6 +156,9 @@ namespace boost
inline indexed_range<const SinglePassRange>
index(const SinglePassRange& rng, Index index_value)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return indexed_range<const SinglePassRange>(index_value, rng);
}
} // 'adaptors'

44
include/boost/range/adaptor/indirected.hpp
View File

@@ -12,6 +12,7 @@
#define BOOST_RANGE_ADAPTOR_INDIRECTED_HPP
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/indirect_iterator.hpp>
namespace boost
@@ -42,18 +43,24 @@ namespace boost
struct indirect_forwarder {};
template< class InputRng >
inline indirected_range<InputRng>
operator|( InputRng& r, indirect_forwarder )
template< class SinglePassRange >
inline indirected_range<SinglePassRange>
operator|( SinglePassRange& r, indirect_forwarder )
{
return indirected_range<InputRng>( r );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return indirected_range<SinglePassRange>( r );
}
template< class InputRng >
inline indirected_range<const InputRng>
operator|( const InputRng& r, indirect_forwarder )
template< class SinglePassRange >
inline indirected_range<const SinglePassRange>
operator|( const SinglePassRange& r, indirect_forwarder )
{
return indirected_range<const InputRng>( r );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return indirected_range<const SinglePassRange>( r );
}
} // 'range_detail'
@@ -68,18 +75,23 @@ namespace boost
range_detail::indirect_forwarder();
}
template<class InputRange>
inline indirected_range<InputRange>
indirect(InputRange& rng)
template<class SinglePassRange>
inline indirected_range<SinglePassRange>
indirect(SinglePassRange& rng)
{
return indirected_range<InputRange>(rng);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return indirected_range<SinglePassRange>(rng);
}
template<class InputRange>
inline indirected_range<const InputRange>
indirect(const InputRange& rng)
template<class SinglePassRange>
inline indirected_range<const SinglePassRange>
indirect(const SinglePassRange& rng)
{
return indirected_range<const InputRange>(rng);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return indirected_range<const SinglePassRange>(rng);
}
} // 'adaptors'

17
include/boost/range/adaptor/map.hpp
View File

@@ -15,6 +15,7 @@
#include <boost/range/iterator_range.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/reference.hpp>
#include <boost/range/concepts.hpp>
namespace boost
{
@@ -120,6 +121,9 @@ namespace boost
inline select_first_range<StdPairRng>
operator|( const StdPairRng& r, map_keys_forwarder )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const StdPairRng>));
return operator|( r,
boost::adaptors::transformed( select_first<StdPairRng>() ) );
}
@@ -128,6 +132,8 @@ namespace boost
inline select_second_mutable_range<StdPairRng>
operator|( StdPairRng& r, map_values_forwarder )
{
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<StdPairRng>));
return operator|( r,
boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
}
@@ -136,6 +142,9 @@ namespace boost
inline select_second_const_range<StdPairRng>
operator|( const StdPairRng& r, map_values_forwarder )
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const StdPairRng>));
return operator|( r,
boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
}
@@ -161,6 +170,9 @@ namespace boost
inline select_first_range<StdPairRange>
keys(const StdPairRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const StdPairRange>));
return select_first_range<StdPairRange>(
range_detail::select_first<StdPairRange>(), rng );
}
@@ -169,6 +181,9 @@ namespace boost
inline select_second_const_range<StdPairRange>
values(const StdPairRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const StdPairRange>));
return select_second_const_range<StdPairRange>(
range_detail::select_second_const<StdPairRange>(), rng );
}
@@ -177,6 +192,8 @@ namespace boost
inline select_second_mutable_range<StdPairRange>
values(StdPairRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<StdPairRange>));
return select_second_mutable_range<StdPairRange>(
range_detail::select_second_mutable<StdPairRange>(), rng );
}

61
include/boost/range/adaptor/replaced.hpp
View File

@@ -17,6 +17,7 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/transform_iterator.hpp>
@@ -82,20 +83,30 @@ namespace boost
void operator=(const replace_holder&);
};
template< class InputRng >
inline replaced_range<InputRng>
operator|( InputRng& r,
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
template< class SinglePassRange >
inline replaced_range<SinglePassRange>
operator|(
SinglePassRange& r,
const replace_holder<
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f )
{
return replaced_range<InputRng>(r, f.val1, f.val2);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return replaced_range<SinglePassRange>(r, f.val1, f.val2);
}
template< class InputRng >
inline replaced_range<const InputRng>
operator|( const InputRng& r,
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
template< class SinglePassRange >
inline replaced_range<const SinglePassRange>
operator|(
const SinglePassRange& r,
const replace_holder<
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
{
return replaced_range<const InputRng>(r, f.val1, f.val2);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return replaced_range<const SinglePassRange>(r, f.val1, f.val2);
}
} // 'range_detail'
@@ -110,22 +121,28 @@ namespace boost
range_detail::forwarder2<range_detail::replace_holder>();
}
template<class InputRange>
inline replaced_range<InputRange>
replace(InputRange& rng,
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
template<class SinglePassRange>
inline replaced_range<SinglePassRange>
replace(SinglePassRange& rng,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
{
return replaced_range<InputRange>(rng, from, to);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return replaced_range<SinglePassRange>(rng, from, to);
}
template<class InputRange>
inline replaced_range<const InputRange>
replace(const InputRange& rng,
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
template<class SinglePassRange>
inline replaced_range<const SinglePassRange>
replace(const SinglePassRange& rng,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type from,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
{
return replaced_range<const InputRange>(rng, from ,to);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return replaced_range<const SinglePassRange>(rng, from ,to);
}
} // 'adaptors'

69
include/boost/range/adaptor/replaced_if.hpp
View File

@@ -17,6 +17,7 @@
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/range/value_type.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/transform_iterator.hpp>
@@ -86,20 +87,34 @@ namespace boost
T m_to;
};
template< class Pred, class InputRng >
inline replaced_if_range<Pred, InputRng>
operator|( InputRng& r,
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
template< class Pred, class SinglePassRange >
inline replaced_if_range<Pred, SinglePassRange>
operator|(
SinglePassRange& r,
const replace_if_holder<
Pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
{
return replaced_if_range<Pred, InputRng>(r, f.pred(), f.to());
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return replaced_if_range<Pred, SinglePassRange>(
r, f.pred(), f.to());
}
template< class Pred, class InputRng >
inline replaced_if_range<Pred, const InputRng>
operator|( const InputRng& r,
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
template< class Pred, class SinglePassRange >
inline replaced_if_range<Pred, const SinglePassRange>
operator|(
const SinglePassRange& r,
const replace_if_holder<
Pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type>& f)
{
return replaced_if_range<Pred, const InputRng>(r, f.pred(), f.to());
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return replaced_if_range<Pred, const SinglePassRange>(
r, f.pred(), f.to());
}
} // 'range_detail'
@@ -113,24 +128,34 @@ namespace boost
replaced_if =
range_detail::forwarder2TU<range_detail::replace_if_holder>();
}
template<class Pred, class InputRange>
inline replaced_if_range<Pred, InputRange>
replace_if(InputRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
template<class Pred, class SinglePassRange>
inline replaced_if_range<Pred, SinglePassRange>
replace_if(SinglePassRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange>::type to)
{
return range_detail::replaced_if_range<Pred, InputRange>(rng, pred, to);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return range_detail::replaced_if_range<Pred, SinglePassRange>(
rng, pred, to);
}
template<class Pred, class InputRange>
inline replaced_if_range<Pred, const InputRange>
replace_if(const InputRange& rng, Pred pred,
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
template<class Pred, class SinglePassRange>
inline replaced_if_range<Pred, const SinglePassRange>
replace_if(
const SinglePassRange& rng,
Pred pred,
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type to)
{
return range_detail::replaced_if_range<Pred, const InputRange>(rng, pred, to);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return range_detail::replaced_if_range<Pred, const SinglePassRange>(
rng, pred, to);
}
} // 'adaptors'
} // 'boost'
#endif // include guard

31
include/boost/range/adaptor/reversed.hpp
View File

@@ -12,6 +12,7 @@
#define BOOST_RANGE_ADAPTOR_REVERSED_HPP
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/reverse_iterator.hpp>
namespace boost
@@ -44,18 +45,24 @@ namespace boost
struct reverse_forwarder {};
template< class BidirectionalRng >
inline reversed_range<BidirectionalRng>
operator|( BidirectionalRng& r, reverse_forwarder )
template< class BidirectionalRange >
inline reversed_range<BidirectionalRange>
operator|( BidirectionalRange& r, reverse_forwarder )
{
return reversed_range<BidirectionalRng>( r );
BOOST_RANGE_CONCEPT_ASSERT((
BidirectionalRangeConcept<BidirectionalRange>));
return reversed_range<BidirectionalRange>( r );
}
template< class BidirectionalRng >
inline reversed_range<const BidirectionalRng>
operator|( const BidirectionalRng& r, reverse_forwarder )
template< class BidirectionalRange >
inline reversed_range<const BidirectionalRange>
operator|( const BidirectionalRange& r, reverse_forwarder )
{
return reversed_range<const BidirectionalRng>( r );
BOOST_RANGE_CONCEPT_ASSERT((
BidirectionalRangeConcept<const BidirectionalRange>));
return reversed_range<const BidirectionalRange>( r );
}
} // 'range_detail'
@@ -74,6 +81,9 @@ namespace boost
inline reversed_range<BidirectionalRange>
reverse(BidirectionalRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
BidirectionalRangeConcept<BidirectionalRange>));
return reversed_range<BidirectionalRange>(rng);
}
@@ -81,6 +91,9 @@ namespace boost
inline reversed_range<const BidirectionalRange>
reverse(const BidirectionalRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
BidirectionalRangeConcept<const BidirectionalRange>));
return reversed_range<const BidirectionalRange>(rng);
}
} // 'adaptors'

13
include/boost/range/adaptor/sliced.hpp
View File

@@ -14,6 +14,7 @@
#include <boost/range/adaptor/argument_fwd.hpp>
#include <boost/range/size_type.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
namespace boost
{
@@ -44,6 +45,9 @@ namespace boost
inline sliced_range<RandomAccessRange>
slice( RandomAccessRange& rng, std::size_t t, std::size_t u )
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<RandomAccessRange>));
BOOST_ASSERT( t <= u && "error in slice indices" );
BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
"second slice index out of bounds" );
@@ -55,6 +59,9 @@ namespace boost
inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type >
slice( const RandomAccessRange& rng, std::size_t t, std::size_t u )
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<const RandomAccessRange>));
BOOST_ASSERT( t <= u && "error in slice indices" );
BOOST_ASSERT( static_cast<std::size_t>(boost::size(rng)) >= u &&
"second slice index out of bounds" );
@@ -66,6 +73,9 @@ namespace boost
inline sliced_range<RandomAccessRange>
operator|( RandomAccessRange& r, const sliced& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<RandomAccessRange>));
return sliced_range<RandomAccessRange>( r, f.t, f.u );
}
@@ -73,6 +83,9 @@ namespace boost
inline sliced_range<const RandomAccessRange>
operator|( const RandomAccessRange& r, const sliced& f )
{
BOOST_RANGE_CONCEPT_ASSERT((
RandomAccessRangeConcept<const RandomAccessRange>));
return sliced_range<const RandomAccessRange>( r, f.t, f.u );
}

47
include/boost/range/adaptor/transformed.hpp
View File

@@ -13,6 +13,7 @@
#include <boost/range/adaptor/argument_fwd.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/utility/result_of.hpp>
@@ -57,20 +58,27 @@ namespace boost
}
};
template< class InputRng, class UnaryFunction >
inline transformed_range<UnaryFunction,InputRng>
operator|( InputRng& r,
template< class SinglePassRange, class UnaryFunction >
inline transformed_range<UnaryFunction,SinglePassRange>
operator|( SinglePassRange& r,
const transform_holder<UnaryFunction>& f )
{
return transformed_range<UnaryFunction,InputRng>( f.val, r );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return transformed_range<UnaryFunction,SinglePassRange>( f.val, r );
}
template< class InputRng, class UnaryFunction >
inline transformed_range<UnaryFunction, const InputRng>
operator|( const InputRng& r,
template< class SinglePassRange, class UnaryFunction >
inline transformed_range<UnaryFunction, const SinglePassRange>
operator|( const SinglePassRange& r,
const transform_holder<UnaryFunction>& f )
{
return transformed_range<UnaryFunction, const InputRng>( f.val, r );
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return transformed_range<UnaryFunction, const SinglePassRange>(
f.val, r);
}
} // 'range_detail'
@@ -86,18 +94,25 @@ namespace boost
range_detail::forwarder<range_detail::transform_holder>();
}
template<class UnaryFunction, class InputRange>
inline transformed_range<UnaryFunction, InputRange>
transform(InputRange& rng, UnaryFunction fn)
template<class UnaryFunction, class SinglePassRange>
inline transformed_range<UnaryFunction, SinglePassRange>
transform(SinglePassRange& rng, UnaryFunction fn)
{
return transformed_range<UnaryFunction, InputRange>(fn, rng);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
return transformed_range<UnaryFunction, SinglePassRange>(fn, rng);
}
template<class UnaryFunction, class InputRange>
inline transformed_range<UnaryFunction, const InputRange>
transform(const InputRange& rng, UnaryFunction fn)
template<class UnaryFunction, class SinglePassRange>
inline transformed_range<UnaryFunction, const SinglePassRange>
transform(const SinglePassRange& rng, UnaryFunction fn)
{
return transformed_range<UnaryFunction, const InputRange>(fn, rng);
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
return transformed_range<UnaryFunction, const SinglePassRange>(
fn, rng);
}
} // 'adaptors'

13
include/boost/range/adaptor/type_erased.hpp
View File

@@ -14,6 +14,7 @@
#include <boost/range/value_type.hpp>
#include <boost/range/iterator_range_core.hpp>
#include <boost/range/any_range.hpp>
#include <boost/range/concepts.hpp>
#include <boost/cast.hpp>
namespace boost
@@ -56,6 +57,9 @@ namespace boost
, Buffer
>)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
typedef typename any_range_type_generator<
SinglePassRange
, Value
@@ -92,6 +96,9 @@ namespace boost
, Buffer
>)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
typedef typename any_range_type_generator<
const SinglePassRange
, Value
@@ -129,6 +136,9 @@ namespace boost
> = type_erased<>()
)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<SinglePassRange>));
typedef typename any_range_type_generator<
SinglePassRange
, Value
@@ -167,6 +177,9 @@ namespace boost
> = type_erased<>()
)
{
BOOST_RANGE_CONCEPT_ASSERT((
SinglePassRangeConcept<const SinglePassRange>));
typedef typename any_range_type_generator<
const SinglePassRange
, Value

7
include/boost/range/adaptor/uniqued.hpp
View File

@@ -12,6 +12,7 @@
#define BOOST_RANGE_ADAPTOR_UNIQUED_IMPL_HPP
#include <boost/range/adaptor/adjacent_filtered.hpp>
#include <boost/range/concepts.hpp>
namespace boost
{
@@ -47,6 +48,7 @@ namespace boost
operator|( ForwardRng& r,
unique_forwarder )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRng>));
return uniqued_range<ForwardRng>(r);
}
@@ -55,6 +57,7 @@ namespace boost
operator|( const ForwardRng& r,
unique_forwarder )
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRng>));
return uniqued_range<const ForwardRng>(r);
}
@@ -74,6 +77,7 @@ namespace boost
inline uniqued_range<ForwardRange>
unique(ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
return uniqued_range<ForwardRange>(rng);
}
@@ -81,6 +85,9 @@ namespace boost
inline uniqued_range<const ForwardRange>
unique(const ForwardRange& rng)
{
BOOST_RANGE_CONCEPT_ASSERT((
ForwardRangeConcept<const ForwardRange>));
return uniqued_range<const ForwardRange>(rng);
}
} // 'adaptors'