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

Merge branch 'develop' to incorporate fixes from trac tickets.

Browse Source
This commit is contained in:
Neil Groves
2014-06-04 18:37:36 +01:00
parent fa629a53bd 60025220f5
commit 36bb8a82fb
65 changed files with 1369 additions and 170 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'

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

@ -58,9 +58,8 @@ namespace boost
OutputIterator out,
BinaryFunction fn)
{
for (; first1 != last1; ++first1, ++first2)
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
{
BOOST_ASSERT( first2 != last2 );
*out = fn(*first1, *first2);
++out;
}

2
include/boost/range/const_iterator.hpp
View File

@ -62,7 +62,7 @@ struct range_const_iterator< T[sz] >
} // namespace range_detail
template<typename C>
template<typename C, typename Enabler=void>
struct range_const_iterator
: range_detail::range_const_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type

20
include/boost/range/detail/any_iterator_wrapper.hpp
View File

@ -19,6 +19,16 @@ namespace boost
{
namespace range_detail
{
template<typename TargetT, typename SourceT>
TargetT& polymorphic_ref_downcast(SourceT& source)
{
#ifdef BOOST_NO_RTTI
return static_cast<TargetT&>(source);
#else
return *boost::polymorphic_downcast<TargetT*>(&source);
#endif
}
template<class Reference, class T>
Reference dereference_cast(T& x)
{
@ -192,7 +202,7 @@ namespace boost
virtual bool equal(const any_single_pass_iterator_interface<Reference, Buffer>& other) const
{
return m_it == boost::polymorphic_downcast<const any_single_pass_iterator_wrapper*>(&other)->m_it;
return m_it == range_detail::polymorphic_ref_downcast<const any_single_pass_iterator_wrapper>(other).m_it;
}
virtual reference dereference() const
@ -284,7 +294,7 @@ namespace boost
virtual bool equal(const any_single_pass_iterator_interface<Reference, Buffer>& other) const
{
return m_it == boost::polymorphic_downcast<const any_forward_iterator_wrapper*>(&other)->m_it;
return m_it == range_detail::polymorphic_ref_downcast<const any_forward_iterator_wrapper>(other).m_it;
}
virtual reference dereference() const
@ -381,7 +391,7 @@ namespace boost
virtual bool equal(const any_single_pass_iterator_interface<Reference, Buffer>& other) const
{
return m_it == boost::polymorphic_downcast<const any_bidirectional_iterator_wrapper*>(&other)->m_it;
return m_it == range_detail::polymorphic_ref_downcast<const any_bidirectional_iterator_wrapper>(other).m_it;
}
virtual reference dereference() const
@ -482,7 +492,7 @@ namespace boost
virtual bool equal(const any_single_pass_iterator_interface<Reference, Buffer>& other) const
{
return m_it == boost::polymorphic_downcast<const any_random_access_iterator_wrapper*>(&other)->m_it;
return m_it == range_detail::polymorphic_ref_downcast<const any_random_access_iterator_wrapper>(other).m_it;
}
virtual void decrement()
@ -502,7 +512,7 @@ namespace boost
virtual Difference distance_to(const any_random_access_iterator_interface<Reference, Difference, Buffer>& other) const
{
return boost::polymorphic_downcast<const any_random_access_iterator_wrapper*>(&other)->m_it - m_it;
return range_detail::polymorphic_ref_downcast<const any_random_access_iterator_wrapper>(other).m_it - m_it;
}
private:

2
include/boost/range/detail/combine_cxx03.hpp
View File

@ -91,7 +91,7 @@ namespace range
#define BOOST_RANGE_combined_seq(z, n, data) boost::data(BOOST_PP_CAT(r,n))
#ifdef BOOST_NO_RVALUE_REFERENCES
#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
#include <boost/range/detail/combine_no_rvalue.hpp>

2
include/boost/range/iterator.hpp
View File

@ -47,7 +47,7 @@ namespace boost
#endif
template< typename C >
template< typename C, typename Enabler=void >
struct range_iterator
{
#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)

64
include/boost/range/mutable_iterator.hpp
View File

@ -31,37 +31,47 @@ namespace boost
// default
//////////////////////////////////////////////////////////////////////////
namespace range_detail {
BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
}
template< typename C >
struct range_mutable_iterator
: range_detail::extract_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
{};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_mutable_iterator< std::pair<Iterator,Iterator> >
namespace range_detail
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
BOOST_RANGE_EXTRACT_OPTIONAL_TYPE( iterator )
template< typename T, std::size_t sz >
struct range_mutable_iterator< T[sz] >
{
typedef T* type;
};
template< typename C >
struct range_mutable_iterator
: range_detail::extract_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type>
{};
//////////////////////////////////////////////////////////////////////////
// pair
//////////////////////////////////////////////////////////////////////////
template< typename Iterator >
struct range_mutable_iterator< std::pair<Iterator,Iterator> >
{
typedef Iterator type;
};
//////////////////////////////////////////////////////////////////////////
// array
//////////////////////////////////////////////////////////////////////////
template< typename T, std::size_t sz >
struct range_mutable_iterator< T[sz] >
{
typedef T* type;
};
} // namespace range_detail
template<typename C, typename Enabler=void>
struct range_mutable_iterator
: range_detail::range_mutable_iterator<
BOOST_DEDUCED_TYPENAME remove_reference<C>::type
>
{
};
} // namespace boost
#endif