forked from boostorg/range
Boost.Range merge from trunk to release.
This is motivated by the need to correct the istream_range, to correct the adaptors.hpp header file, and correct the return types of various range algorithms. [SVN r61517]
This commit is contained in:
Neil Groves
@@ -28,11 +28,11 @@
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Iter, class Pred, bool default_pass >
|
||||
class skip_iterator
|
||||
: public boost::iterator_adaptor<
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Iter, class Pred, bool default_pass >
|
||||
class skip_iterator
|
||||
: public boost::iterator_adaptor<
|
||||
skip_iterator<Iter,Pred,default_pass>,
|
||||
Iter,
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
|
||||
@@ -40,10 +40,10 @@ namespace boost
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::reference,
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
|
||||
>
|
||||
, private Pred
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_adaptor<
|
||||
, private Pred
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_adaptor<
|
||||
skip_iterator<Iter,Pred,default_pass>,
|
||||
Iter,
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
|
||||
@@ -52,9 +52,9 @@ namespace boost
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
|
||||
> base_t;
|
||||
|
||||
public:
|
||||
public:
|
||||
typedef Pred pred_t;
|
||||
typedef Iter iter_t;
|
||||
typedef Iter iter_t;
|
||||
|
||||
skip_iterator() : m_last() {}
|
||||
|
||||
@@ -66,169 +66,169 @@ namespace boost
|
||||
move_to_next_valid();
|
||||
}
|
||||
|
||||
template<class OtherIter>
|
||||
skip_iterator( const skip_iterator<OtherIter, pred_t, default_pass>& other )
|
||||
: base_t(other.base())
|
||||
, pred_t(other)
|
||||
, m_last(other.m_last) {}
|
||||
template<class OtherIter>
|
||||
skip_iterator( const skip_iterator<OtherIter, pred_t, default_pass>& other )
|
||||
: base_t(other.base())
|
||||
, pred_t(other)
|
||||
, m_last(other.m_last) {}
|
||||
|
||||
void move_to_next_valid()
|
||||
{
|
||||
iter_t& it = this->base_reference();
|
||||
pred_t& bi_pred = *this;
|
||||
if (it != m_last)
|
||||
{
|
||||
if (default_pass)
|
||||
{
|
||||
iter_t nxt = ::boost::next(it);
|
||||
while (nxt != m_last && !bi_pred(*it, *nxt))
|
||||
{
|
||||
++it;
|
||||
++nxt;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iter_t nxt = ::boost::next(it);
|
||||
for(; nxt != m_last; ++it, ++nxt)
|
||||
{
|
||||
if (bi_pred(*it, *nxt))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (nxt == m_last)
|
||||
{
|
||||
it = m_last;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
iter_t& it = this->base_reference();
|
||||
pred_t& bi_pred = *this;
|
||||
if (it != m_last)
|
||||
{
|
||||
if (default_pass)
|
||||
{
|
||||
iter_t nxt = ::boost::next(it);
|
||||
while (nxt != m_last && !bi_pred(*it, *nxt))
|
||||
{
|
||||
++it;
|
||||
++nxt;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
iter_t nxt = ::boost::next(it);
|
||||
for(; nxt != m_last; ++it, ++nxt)
|
||||
{
|
||||
if (bi_pred(*it, *nxt))
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (nxt == m_last)
|
||||
{
|
||||
it = m_last;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void increment()
|
||||
{
|
||||
iter_t& it = this->base_reference();
|
||||
BOOST_ASSERT( it != m_last );
|
||||
++it;
|
||||
move_to_next_valid();
|
||||
}
|
||||
void increment()
|
||||
{
|
||||
iter_t& it = this->base_reference();
|
||||
BOOST_ASSERT( it != m_last );
|
||||
++it;
|
||||
move_to_next_valid();
|
||||
}
|
||||
|
||||
iter_t m_last;
|
||||
};
|
||||
};
|
||||
|
||||
template< class P, class R, bool default_pass >
|
||||
struct adjacent_filter_range
|
||||
: iterator_range< skip_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
|
||||
P,
|
||||
default_pass
|
||||
template< class P, class R, bool default_pass >
|
||||
struct adjacent_filter_range
|
||||
: iterator_range< skip_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
|
||||
P,
|
||||
default_pass
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef skip_iterator<
|
||||
{
|
||||
private:
|
||||
typedef skip_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
|
||||
P,
|
||||
default_pass
|
||||
>
|
||||
skip_iter;
|
||||
skip_iter;
|
||||
|
||||
typedef iterator_range<skip_iter>
|
||||
base_range;
|
||||
typedef iterator_range<skip_iter>
|
||||
base_range;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
|
||||
typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
|
||||
|
||||
public:
|
||||
adjacent_filter_range( const P& p, R& r )
|
||||
: base_range( skip_iter( boost::begin(r), boost::end(r), p),
|
||||
skip_iter( boost::end(r), boost::end(r), p) )
|
||||
{
|
||||
}
|
||||
};
|
||||
public:
|
||||
adjacent_filter_range( const P& p, R& r )
|
||||
: base_range( skip_iter( boost::begin(r), boost::end(r), p),
|
||||
skip_iter( boost::end(r), boost::end(r), p) )
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct adjacent_holder : holder<T>
|
||||
{
|
||||
adjacent_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
template< class T >
|
||||
struct adjacent_holder : holder<T>
|
||||
{
|
||||
adjacent_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct adjacent_excl_holder : holder<T>
|
||||
{
|
||||
adjacent_excl_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
template< class T >
|
||||
struct adjacent_excl_holder : holder<T>
|
||||
{
|
||||
adjacent_excl_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
|
||||
operator|( ForwardRng& r,
|
||||
const adjacent_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
|
||||
}
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
|
||||
operator|( ForwardRng& r,
|
||||
const adjacent_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
|
||||
}
|
||||
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
|
||||
operator|( const ForwardRng& r,
|
||||
const adjacent_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate,
|
||||
const ForwardRng, true>( f.val, r );
|
||||
}
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
|
||||
operator|( const ForwardRng& r,
|
||||
const adjacent_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate,
|
||||
const ForwardRng, true>( f.val, r );
|
||||
}
|
||||
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
|
||||
operator|( ForwardRng& r,
|
||||
const adjacent_excl_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
|
||||
}
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
|
||||
operator|( ForwardRng& r,
|
||||
const adjacent_excl_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
|
||||
}
|
||||
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
|
||||
operator|( const ForwardRng& r,
|
||||
const adjacent_excl_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate,
|
||||
const ForwardRng, false>( f.val, r );
|
||||
}
|
||||
template< class ForwardRng, class BinPredicate >
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
|
||||
operator|( const ForwardRng& r,
|
||||
const adjacent_excl_holder<BinPredicate>& f )
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate,
|
||||
const ForwardRng, false>( f.val, r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
} // 'range_detail'
|
||||
|
||||
// Bring adjacent_filter_range into the boost namespace so that users of
|
||||
// this library may specify the return type of the '|' operator and
|
||||
// adjacent_filter()
|
||||
using range_detail::adjacent_filter_range;
|
||||
// Bring adjacent_filter_range into the boost namespace so that users of
|
||||
// this library may specify the return type of the '|' operator and
|
||||
// adjacent_filter()
|
||||
using range_detail::adjacent_filter_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::adjacent_holder>
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::adjacent_holder>
|
||||
adjacent_filtered =
|
||||
range_detail::forwarder<range_detail::adjacent_holder>();
|
||||
|
||||
const range_detail::forwarder<range_detail::adjacent_excl_holder>
|
||||
adjacent_filtered_excl =
|
||||
range_detail::forwarder<range_detail::adjacent_excl_holder>();
|
||||
}
|
||||
const range_detail::forwarder<range_detail::adjacent_excl_holder>
|
||||
adjacent_filtered_excl =
|
||||
range_detail::forwarder<range_detail::adjacent_excl_holder>();
|
||||
}
|
||||
|
||||
template<class ForwardRng, class BinPredicate>
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
|
||||
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
|
||||
}
|
||||
template<class ForwardRng, class BinPredicate>
|
||||
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
|
||||
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
|
||||
}
|
||||
|
||||
template<class ForwardRng, class BinPredicate>
|
||||
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
|
||||
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
|
||||
}
|
||||
template<class ForwardRng, class BinPredicate>
|
||||
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
|
||||
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
|
||||
{
|
||||
return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
|
||||
}
|
||||
|
||||
} // 'adaptors'
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -20,57 +20,57 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class T >
|
||||
struct holder
|
||||
{
|
||||
T val;
|
||||
holder( T t ) : val(t)
|
||||
{ }
|
||||
};
|
||||
namespace range_detail
|
||||
{
|
||||
template< class T >
|
||||
struct holder
|
||||
{
|
||||
T val;
|
||||
holder( T t ) : val(t)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct holder2
|
||||
{
|
||||
T val1, val2;
|
||||
holder2( T t, T u ) : val1(t), val2(u)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< template<class> class Holder >
|
||||
struct forwarder
|
||||
{
|
||||
template< class T >
|
||||
Holder<T> operator()( T t ) const
|
||||
{
|
||||
return Holder<T>(t);
|
||||
}
|
||||
};
|
||||
template< class T >
|
||||
struct holder2
|
||||
{
|
||||
T val1, val2;
|
||||
holder2( T t, T u ) : val1(t), val2(u)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< template<class> class Holder >
|
||||
struct forwarder
|
||||
{
|
||||
template< class T >
|
||||
Holder<T> operator()( T t ) const
|
||||
{
|
||||
return Holder<T>(t);
|
||||
}
|
||||
};
|
||||
|
||||
template< template<class> class Holder >
|
||||
struct forwarder2
|
||||
{
|
||||
template< class T >
|
||||
Holder<T> operator()( T t, T u ) const
|
||||
{
|
||||
return Holder<T>(t,u);
|
||||
}
|
||||
};
|
||||
template< template<class> class Holder >
|
||||
struct forwarder2
|
||||
{
|
||||
template< class T >
|
||||
Holder<T> operator()( T t, T u ) const
|
||||
{
|
||||
return Holder<T>(t,u);
|
||||
}
|
||||
};
|
||||
|
||||
template< template<class,class> class Holder >
|
||||
struct forwarder2TU
|
||||
{
|
||||
template< class T, class U >
|
||||
Holder<T, U> operator()( T t, U u ) const
|
||||
{
|
||||
return Holder<T, U>(t, u);
|
||||
}
|
||||
};
|
||||
template< template<class,class> class Holder >
|
||||
struct forwarder2TU
|
||||
{
|
||||
template< class T, class U >
|
||||
Holder<T, U> operator()( T t, U u ) const
|
||||
{
|
||||
return Holder<T, U>(t, u);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
|
||||
@@ -18,40 +18,40 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace adaptors
|
||||
{
|
||||
struct copied
|
||||
{
|
||||
copied(std::size_t t_, std::size_t u_)
|
||||
namespace adaptors
|
||||
{
|
||||
struct copied
|
||||
{
|
||||
copied(std::size_t t_, std::size_t u_)
|
||||
: t(t_), u(u_) {}
|
||||
|
||||
std::size_t t;
|
||||
std::size_t u;
|
||||
};
|
||||
};
|
||||
|
||||
template< class CopyableRandomAccessRng >
|
||||
inline CopyableRandomAccessRng
|
||||
operator|( const CopyableRandomAccessRng& r, const copied& f )
|
||||
{
|
||||
iterator_range<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const
|
||||
CopyableRandomAccessRng>::type >
|
||||
temp( adaptors::slice( r, f.t, f.u ) );
|
||||
return CopyableRandomAccessRng( temp.begin(), temp.end() );
|
||||
}
|
||||
template< class CopyableRandomAccessRng >
|
||||
inline CopyableRandomAccessRng
|
||||
operator|( const CopyableRandomAccessRng& r, const copied& f )
|
||||
{
|
||||
iterator_range<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const
|
||||
CopyableRandomAccessRng>::type >
|
||||
temp( adaptors::slice( r, f.t, f.u ) );
|
||||
return CopyableRandomAccessRng( temp.begin(), temp.end() );
|
||||
}
|
||||
|
||||
template<class CopyableRandomAccessRange>
|
||||
inline CopyableRandomAccessRange
|
||||
copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
|
||||
{
|
||||
iterator_range<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const
|
||||
CopyableRandomAccessRange>::type> temp(
|
||||
adaptors::slice(rng, t, u));
|
||||
template<class CopyableRandomAccessRange>
|
||||
inline CopyableRandomAccessRange
|
||||
copy(const CopyableRandomAccessRange& rng, std::size_t t, std::size_t u)
|
||||
{
|
||||
iterator_range<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const
|
||||
CopyableRandomAccessRange>::type> temp(
|
||||
adaptors::slice(rng, t, u));
|
||||
|
||||
return CopyableRandomAccessRange( temp.begin(), temp.end() );
|
||||
}
|
||||
} // 'adaptors'
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -17,84 +17,84 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class P, class R >
|
||||
struct filter_range :
|
||||
namespace range_detail
|
||||
{
|
||||
template< class P, class R >
|
||||
struct filter_range :
|
||||
boost::iterator_range<
|
||||
boost::filter_iterator< P,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::filter_iterator< P,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
> base;
|
||||
public:
|
||||
filter_range( P p, R& r )
|
||||
: base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
|
||||
make_filter_iterator( p, boost::end(r), boost::end(r) ) )
|
||||
{ }
|
||||
};
|
||||
public:
|
||||
filter_range( P p, R& r )
|
||||
: base( make_filter_iterator( p, boost::begin(r), boost::end(r) ),
|
||||
make_filter_iterator( p, boost::end(r), boost::end(r) ) )
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct filter_holder : holder<T>
|
||||
{
|
||||
filter_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
template< class T >
|
||||
struct filter_holder : holder<T>
|
||||
{
|
||||
filter_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class InputRng, class Predicate >
|
||||
inline filter_range<Predicate, InputRng>
|
||||
operator|( InputRng& r,
|
||||
const filter_holder<Predicate>& f )
|
||||
{
|
||||
return filter_range<Predicate, InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
template< class InputRng, class Predicate >
|
||||
inline filter_range<Predicate, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const filter_holder<Predicate>& f )
|
||||
{
|
||||
return filter_range<Predicate, const InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
// Unusual use of 'using' is intended to bring filter_range into the boost namespace
|
||||
// while leaving the mechanics of the '|' operator in range_detail and maintain
|
||||
// argument dependent lookup.
|
||||
// filter_range logically needs to be in the boost namespace to allow user of
|
||||
// the library to define the return type for filter()
|
||||
using range_detail::filter_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::filter_holder>
|
||||
filtered =
|
||||
range_detail::forwarder<range_detail::filter_holder>();
|
||||
}
|
||||
|
||||
template<class InputRange, class Predicate>
|
||||
inline filter_range<Predicate, InputRange>
|
||||
filter(InputRange& rng, Predicate filter_pred)
|
||||
{
|
||||
return range_detail::filter_range<Predicate, InputRange>( filter_pred, rng );
|
||||
}
|
||||
|
||||
template<class InputRange, class Predicate>
|
||||
inline filter_range<Predicate, const InputRange>
|
||||
filter(const InputRange& rng, Predicate filter_pred)
|
||||
{
|
||||
return range_detail::filter_range<Predicate, const InputRange>( filter_pred, rng );
|
||||
template< class InputRng, class Predicate >
|
||||
inline filter_range<Predicate, InputRng>
|
||||
operator|( InputRng& r,
|
||||
const filter_holder<Predicate>& f )
|
||||
{
|
||||
return filter_range<Predicate, InputRng>( f.val, r );
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
template< class InputRng, class Predicate >
|
||||
inline filter_range<Predicate, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const filter_holder<Predicate>& f )
|
||||
{
|
||||
return filter_range<Predicate, const InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
// Unusual use of 'using' is intended to bring filter_range into the boost namespace
|
||||
// while leaving the mechanics of the '|' operator in range_detail and maintain
|
||||
// argument dependent lookup.
|
||||
// filter_range logically needs to be in the boost namespace to allow user of
|
||||
// the library to define the return type for filter()
|
||||
using range_detail::filter_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::filter_holder>
|
||||
filtered =
|
||||
range_detail::forwarder<range_detail::filter_holder>();
|
||||
}
|
||||
|
||||
template<class InputRange, class Predicate>
|
||||
inline filter_range<Predicate, InputRange>
|
||||
filter(InputRange& rng, Predicate filter_pred)
|
||||
{
|
||||
return range_detail::filter_range<Predicate, InputRange>( filter_pred, rng );
|
||||
}
|
||||
|
||||
template<class InputRange, class Predicate>
|
||||
inline filter_range<Predicate, const InputRange>
|
||||
filter(const InputRange& rng, Predicate filter_pred)
|
||||
{
|
||||
return range_detail::filter_range<Predicate, const InputRange>( filter_pred, rng );
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -40,56 +40,56 @@ namespace boost
|
||||
};
|
||||
}
|
||||
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Iter >
|
||||
class indexed_iterator
|
||||
: public boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
|
||||
base;
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Iter >
|
||||
class indexed_iterator
|
||||
: public boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_adaptor< indexed_iterator<Iter>, Iter >
|
||||
base;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME base::difference_type index_type;
|
||||
typedef BOOST_DEDUCED_TYPENAME base::difference_type index_type;
|
||||
|
||||
index_type m_index;
|
||||
index_type m_index;
|
||||
|
||||
public:
|
||||
explicit indexed_iterator( Iter i, index_type index )
|
||||
: base(i), m_index(index)
|
||||
{
|
||||
BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
|
||||
}
|
||||
public:
|
||||
explicit indexed_iterator( Iter i, index_type index )
|
||||
: base(i), m_index(index)
|
||||
{
|
||||
BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
|
||||
}
|
||||
|
||||
index_type index() const
|
||||
{
|
||||
return m_index;
|
||||
}
|
||||
index_type index() const
|
||||
{
|
||||
return m_index;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class boost::iterator_core_access;
|
||||
private:
|
||||
friend class boost::iterator_core_access;
|
||||
|
||||
void increment()
|
||||
{
|
||||
void increment()
|
||||
{
|
||||
++m_index;
|
||||
++(this->base_reference());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void decrement()
|
||||
void decrement()
|
||||
{
|
||||
BOOST_ASSERT( m_index > 0 && "Indexed Iterator out of bounds" );
|
||||
--m_index;
|
||||
--(this->base_reference());
|
||||
}
|
||||
|
||||
void advance( index_type n )
|
||||
void advance( index_type n )
|
||||
{
|
||||
m_index += n;
|
||||
BOOST_ASSERT( m_index >= 0 && "Indexed Iterator out of bounds" );
|
||||
this->base_reference() += n;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template< class Rng >
|
||||
struct indexed_range :
|
||||
@@ -107,45 +107,45 @@ namespace boost
|
||||
{ }
|
||||
};
|
||||
|
||||
} // 'range_detail'
|
||||
} // 'range_detail'
|
||||
|
||||
// Make this available to users of this library. It will sometimes be
|
||||
// required since it is the return type of operator '|' and
|
||||
// index().
|
||||
using range_detail::indexed_range;
|
||||
// Make this available to users of this library. It will sometimes be
|
||||
// required since it is the return type of operator '|' and
|
||||
// index().
|
||||
using range_detail::indexed_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace adaptors
|
||||
{
|
||||
template< class SinglePassRange >
|
||||
inline indexed_range<SinglePassRange>
|
||||
operator|( SinglePassRange& r,
|
||||
const indexed& f )
|
||||
{
|
||||
return indexed_range<SinglePassRange>( f.val, r );
|
||||
}
|
||||
|
||||
template< class SinglePassRange >
|
||||
inline indexed_range<const SinglePassRange>
|
||||
operator|( const SinglePassRange& r,
|
||||
const indexed& f )
|
||||
{
|
||||
return indexed_range<const SinglePassRange>( f.val, r );
|
||||
}
|
||||
|
||||
template<class SinglePassRange, class Index>
|
||||
inline indexed_range<SinglePassRange>
|
||||
index(SinglePassRange& rng, Index index_value)
|
||||
{
|
||||
return indexed_range<SinglePassRange>(index_value, rng);
|
||||
}
|
||||
|
||||
template<class SinglePassRange, class Index>
|
||||
inline indexed_range<const SinglePassRange>
|
||||
index(const SinglePassRange& rng, Index index_value)
|
||||
{
|
||||
return indexed_range<const SinglePassRange>(index_value, rng);
|
||||
inline indexed_range<SinglePassRange>
|
||||
operator|( SinglePassRange& r,
|
||||
const indexed& f )
|
||||
{
|
||||
return indexed_range<SinglePassRange>( f.val, r );
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
template< class SinglePassRange >
|
||||
inline indexed_range<const SinglePassRange>
|
||||
operator|( const SinglePassRange& r,
|
||||
const indexed& f )
|
||||
{
|
||||
return indexed_range<const SinglePassRange>( f.val, r );
|
||||
}
|
||||
|
||||
template<class SinglePassRange, class Index>
|
||||
inline indexed_range<SinglePassRange>
|
||||
index(SinglePassRange& rng, Index index_value)
|
||||
{
|
||||
return indexed_range<SinglePassRange>(index_value, rng);
|
||||
}
|
||||
|
||||
template<class SinglePassRange, class Index>
|
||||
inline indexed_range<const SinglePassRange>
|
||||
index(const SinglePassRange& rng, Index index_value)
|
||||
{
|
||||
return indexed_range<const SinglePassRange>(index_value, rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -16,72 +16,72 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class R >
|
||||
struct indirect_range :
|
||||
public boost::iterator_range<
|
||||
namespace range_detail
|
||||
{
|
||||
template< class R >
|
||||
struct indirect_range :
|
||||
public boost::iterator_range<
|
||||
boost::indirect_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::indirect_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
base;
|
||||
base;
|
||||
|
||||
public:
|
||||
explicit indirect_range( R& r )
|
||||
public:
|
||||
explicit indirect_range( R& r )
|
||||
: base( r )
|
||||
{ }
|
||||
};
|
||||
{ }
|
||||
};
|
||||
|
||||
struct indirect_forwarder {};
|
||||
struct indirect_forwarder {};
|
||||
|
||||
template< class InputRng >
|
||||
inline indirect_range<InputRng>
|
||||
operator|( InputRng& r, indirect_forwarder )
|
||||
{
|
||||
return indirect_range<InputRng>( r );
|
||||
}
|
||||
template< class InputRng >
|
||||
inline indirect_range<InputRng>
|
||||
operator|( InputRng& r, indirect_forwarder )
|
||||
{
|
||||
return indirect_range<InputRng>( r );
|
||||
}
|
||||
|
||||
template< class InputRng >
|
||||
inline indirect_range<const InputRng>
|
||||
operator|( const InputRng& r, indirect_forwarder )
|
||||
{
|
||||
return indirect_range<const InputRng>( r );
|
||||
}
|
||||
template< class InputRng >
|
||||
inline indirect_range<const InputRng>
|
||||
operator|( const InputRng& r, indirect_forwarder )
|
||||
{
|
||||
return indirect_range<const InputRng>( r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::indirect_range;
|
||||
using range_detail::indirect_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::indirect_forwarder indirected =
|
||||
range_detail::indirect_forwarder();
|
||||
}
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::indirect_forwarder indirected =
|
||||
range_detail::indirect_forwarder();
|
||||
}
|
||||
|
||||
template<class InputRange>
|
||||
inline indirect_range<InputRange>
|
||||
indirect(InputRange& rng)
|
||||
{
|
||||
return indirect_range<InputRange>(rng);
|
||||
}
|
||||
template<class InputRange>
|
||||
inline indirect_range<InputRange>
|
||||
indirect(InputRange& rng)
|
||||
{
|
||||
return indirect_range<InputRange>(rng);
|
||||
}
|
||||
|
||||
template<class InputRange>
|
||||
inline indirect_range<const InputRange>
|
||||
indirect(const InputRange& rng)
|
||||
{
|
||||
return indirect_range<const InputRange>(rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
template<class InputRange>
|
||||
inline indirect_range<const InputRange>
|
||||
indirect(const InputRange& rng)
|
||||
{
|
||||
return indirect_range<const InputRange>(rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
+142
-142
@@ -17,161 +17,161 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
struct map_keys_forwarder {};
|
||||
struct map_values_forwarder {};
|
||||
namespace range_detail
|
||||
{
|
||||
struct map_keys_forwarder {};
|
||||
struct map_values_forwarder {};
|
||||
|
||||
template< class Map >
|
||||
struct select_first
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
|
||||
result_type;
|
||||
template< class Map >
|
||||
struct select_first
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef const BOOST_DEDUCED_TYPENAME pair_t::first_type&
|
||||
result_type;
|
||||
|
||||
result_type operator()( const pair_t& r ) const
|
||||
{
|
||||
return r.first;
|
||||
}
|
||||
};
|
||||
result_type operator()( const pair_t& r ) const
|
||||
{
|
||||
return r.first;
|
||||
}
|
||||
};
|
||||
|
||||
template< class Map >
|
||||
struct select_second_mutable
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
|
||||
template< class Map >
|
||||
struct select_second_mutable
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef BOOST_DEDUCED_TYPENAME pair_t::second_type& result_type;
|
||||
|
||||
result_type operator()( pair_t& r ) const
|
||||
{
|
||||
return r.second;
|
||||
}
|
||||
};
|
||||
result_type operator()( pair_t& r ) const
|
||||
{
|
||||
return r.second;
|
||||
}
|
||||
};
|
||||
|
||||
template< class Map >
|
||||
struct select_second_const
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
|
||||
result_type;
|
||||
|
||||
result_type operator()( const pair_t& r ) const
|
||||
{
|
||||
return r.second;
|
||||
}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_first_range
|
||||
: public transform_range<
|
||||
select_first<StdPairRng>,
|
||||
const StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
|
||||
public:
|
||||
typedef select_first<StdPairRng> transform_fn_type;
|
||||
typedef const StdPairRng source_range_type;
|
||||
template< class Map >
|
||||
struct select_second_const
|
||||
{
|
||||
typedef BOOST_DEDUCED_TYPENAME Map::value_type pair_t;
|
||||
typedef const BOOST_DEDUCED_TYPENAME pair_t::second_type&
|
||||
result_type;
|
||||
|
||||
result_type operator()( const pair_t& r ) const
|
||||
{
|
||||
return r.second;
|
||||
}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_first_range
|
||||
: public transform_range<
|
||||
select_first<StdPairRng>,
|
||||
const StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_first<StdPairRng>, const StdPairRng> base;
|
||||
public:
|
||||
typedef select_first<StdPairRng> transform_fn_type;
|
||||
typedef const StdPairRng source_range_type;
|
||||
|
||||
select_first_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
select_first_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
|
||||
select_first_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_second_mutable_range
|
||||
: public transform_range<
|
||||
select_second_mutable<StdPairRng>,
|
||||
StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
|
||||
public:
|
||||
typedef select_second_mutable<StdPairRng> transform_fn_type;
|
||||
typedef StdPairRng source_range_type;
|
||||
select_first_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_second_mutable_range
|
||||
: public transform_range<
|
||||
select_second_mutable<StdPairRng>,
|
||||
StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_second_mutable<StdPairRng>, StdPairRng> base;
|
||||
public:
|
||||
typedef select_second_mutable<StdPairRng> transform_fn_type;
|
||||
typedef StdPairRng source_range_type;
|
||||
|
||||
select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
|
||||
select_second_mutable_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_second_const_range
|
||||
: public transform_range<
|
||||
select_second_const<StdPairRng>,
|
||||
const StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
|
||||
public:
|
||||
typedef select_second_const<StdPairRng> transform_fn_type;
|
||||
typedef const StdPairRng source_range_type;
|
||||
select_second_mutable_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template<class StdPairRng>
|
||||
class select_second_const_range
|
||||
: public transform_range<
|
||||
select_second_const<StdPairRng>,
|
||||
const StdPairRng>
|
||||
{
|
||||
typedef transform_range<select_second_const<StdPairRng>, const StdPairRng> base;
|
||||
public:
|
||||
typedef select_second_const<StdPairRng> transform_fn_type;
|
||||
typedef const StdPairRng source_range_type;
|
||||
|
||||
select_second_const_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
select_second_const_range(transform_fn_type fn, source_range_type& rng)
|
||||
: base(fn, rng)
|
||||
{
|
||||
}
|
||||
|
||||
select_second_const_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template< class StdPairRng >
|
||||
inline select_first_range<StdPairRng>
|
||||
operator|( const StdPairRng& r, map_keys_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_first<StdPairRng>() ) );
|
||||
}
|
||||
select_second_const_range(const base& other) : base(other) {}
|
||||
};
|
||||
|
||||
template< class StdPairRng >
|
||||
inline select_first_range<StdPairRng>
|
||||
operator|( const StdPairRng& r, map_keys_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_first<StdPairRng>() ) );
|
||||
}
|
||||
|
||||
template< class StdPairRng >
|
||||
inline select_second_mutable_range<StdPairRng>
|
||||
operator|( StdPairRng& r, map_values_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
|
||||
}
|
||||
template< class StdPairRng >
|
||||
inline select_second_mutable_range<StdPairRng>
|
||||
operator|( StdPairRng& r, map_values_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
|
||||
}
|
||||
|
||||
template< class StdPairRng >
|
||||
inline select_second_const_range<StdPairRng>
|
||||
operator|( const StdPairRng& r, map_values_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::select_first_range;
|
||||
using range_detail::select_second_mutable_range;
|
||||
using range_detail::select_second_const_range;
|
||||
template< class StdPairRng >
|
||||
inline select_second_const_range<StdPairRng>
|
||||
operator|( const StdPairRng& r, map_values_forwarder )
|
||||
{
|
||||
return operator|( r,
|
||||
boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::select_first_range;
|
||||
using range_detail::select_second_mutable_range;
|
||||
using range_detail::select_second_const_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::map_keys_forwarder map_keys =
|
||||
range_detail::map_keys_forwarder();
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::map_keys_forwarder map_keys =
|
||||
range_detail::map_keys_forwarder();
|
||||
|
||||
const range_detail::map_values_forwarder map_values =
|
||||
range_detail::map_values_forwarder();
|
||||
}
|
||||
|
||||
template<class StdPairRange>
|
||||
inline select_first_range<StdPairRange>
|
||||
keys(const StdPairRange& rng)
|
||||
{
|
||||
return select_first_range<StdPairRange>(
|
||||
range_detail::select_first<StdPairRange>(), rng );
|
||||
}
|
||||
|
||||
template<class StdPairRange>
|
||||
inline select_second_const_range<StdPairRange>
|
||||
values(const StdPairRange& rng)
|
||||
{
|
||||
return select_second_const_range<StdPairRange>(
|
||||
range_detail::select_second_const<StdPairRange>(), rng );
|
||||
const range_detail::map_values_forwarder map_values =
|
||||
range_detail::map_values_forwarder();
|
||||
}
|
||||
|
||||
template<class StdPairRange>
|
||||
inline select_first_range<StdPairRange>
|
||||
keys(const StdPairRange& rng)
|
||||
{
|
||||
return select_first_range<StdPairRange>(
|
||||
range_detail::select_first<StdPairRange>(), rng );
|
||||
}
|
||||
|
||||
template<class StdPairRange>
|
||||
inline select_second_const_range<StdPairRange>
|
||||
values(const StdPairRange& rng)
|
||||
{
|
||||
return select_second_const_range<StdPairRange>(
|
||||
range_detail::select_second_const<StdPairRange>(), rng );
|
||||
}
|
||||
|
||||
template<class StdPairRange>
|
||||
@@ -181,8 +181,8 @@ namespace boost
|
||||
return select_second_mutable_range<StdPairRange>(
|
||||
range_detail::select_second_mutable<StdPairRange>(), rng );
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -22,99 +22,99 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Value >
|
||||
class replace_value
|
||||
{
|
||||
public:
|
||||
typedef const Value& result_type;
|
||||
typedef const Value& first_argument_type;
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Value >
|
||||
class replace_value
|
||||
{
|
||||
public:
|
||||
typedef const Value& result_type;
|
||||
typedef const Value& first_argument_type;
|
||||
|
||||
replace_value(const Value& from, const Value& to)
|
||||
: m_from(from), m_to(to)
|
||||
{
|
||||
}
|
||||
replace_value(const Value& from, const Value& to)
|
||||
: m_from(from), m_to(to)
|
||||
{
|
||||
}
|
||||
|
||||
const Value& operator()(const Value& x) const
|
||||
{
|
||||
return (x == m_from) ? m_to : x;
|
||||
}
|
||||
const Value& operator()(const Value& x) const
|
||||
{
|
||||
return (x == m_from) ? m_to : x;
|
||||
}
|
||||
|
||||
private:
|
||||
Value m_from;
|
||||
Value m_to;
|
||||
};
|
||||
private:
|
||||
Value m_from;
|
||||
Value m_to;
|
||||
};
|
||||
|
||||
template< class R >
|
||||
class replace_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
|
||||
{
|
||||
private:
|
||||
typedef replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
|
||||
template< class R >
|
||||
class replace_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
|
||||
{
|
||||
private:
|
||||
typedef replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
|
||||
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value< BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
|
||||
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
|
||||
|
||||
replace_range( R& r, value_type from, value_type to )
|
||||
: base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
|
||||
make_transform_iterator( boost::end(r), Fn(from, to) ) )
|
||||
{ }
|
||||
};
|
||||
replace_range( R& r, value_type from, value_type to )
|
||||
: base_t( make_transform_iterator( boost::begin(r), Fn(from, to) ),
|
||||
make_transform_iterator( boost::end(r), Fn(from, to) ) )
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T >
|
||||
class replace_holder : public holder2<T>
|
||||
{
|
||||
public:
|
||||
replace_holder( const T& from, const T& to )
|
||||
: holder2<T>(from, to)
|
||||
{ }
|
||||
private:
|
||||
// not assignable
|
||||
void operator=(const replace_holder&);
|
||||
};
|
||||
template< class T >
|
||||
class replace_holder : public holder2<T>
|
||||
{
|
||||
public:
|
||||
replace_holder( const T& from, const T& to )
|
||||
: holder2<T>(from, to)
|
||||
{ }
|
||||
private:
|
||||
// not assignable
|
||||
void operator=(const replace_holder&);
|
||||
};
|
||||
|
||||
template< class InputRng >
|
||||
inline replace_range<InputRng>
|
||||
operator|( InputRng& r,
|
||||
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_range<InputRng>(r, f.val1, f.val2);
|
||||
}
|
||||
template< class InputRng >
|
||||
inline replace_range<InputRng>
|
||||
operator|( InputRng& r,
|
||||
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_range<InputRng>(r, f.val1, f.val2);
|
||||
}
|
||||
|
||||
template< class InputRng >
|
||||
inline replace_range<const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_range<const InputRng>(r, f.val1, f.val2);
|
||||
}
|
||||
} // 'range_detail'
|
||||
template< class InputRng >
|
||||
inline replace_range<const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const replace_holder<BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_range<const InputRng>(r, f.val1, f.val2);
|
||||
}
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::replace_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder2<range_detail::replace_holder>
|
||||
replaced =
|
||||
range_detail::forwarder2<range_detail::replace_holder>();
|
||||
}
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder2<range_detail::replace_holder>
|
||||
replaced =
|
||||
range_detail::forwarder2<range_detail::replace_holder>();
|
||||
}
|
||||
|
||||
template<class InputRange>
|
||||
inline replace_range<InputRange>
|
||||
replace(InputRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
|
||||
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
|
||||
template<class InputRange>
|
||||
inline replace_range<InputRange>
|
||||
replace(InputRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type from,
|
||||
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
|
||||
{
|
||||
return replace_range<InputRange>(rng, from, to);
|
||||
}
|
||||
@@ -128,7 +128,7 @@ namespace boost
|
||||
return replace_range<const InputRange>(rng, from ,to);
|
||||
}
|
||||
|
||||
} // 'adaptors'
|
||||
} // 'adaptors'
|
||||
} // 'boost'
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -22,115 +22,115 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Pred, class Value >
|
||||
class replace_value_if
|
||||
{
|
||||
public:
|
||||
typedef const Value& result_type;
|
||||
typedef const Value& first_argument_type;
|
||||
namespace range_detail
|
||||
{
|
||||
template< class Pred, class Value >
|
||||
class replace_value_if
|
||||
{
|
||||
public:
|
||||
typedef const Value& result_type;
|
||||
typedef const Value& first_argument_type;
|
||||
|
||||
replace_value_if(const Pred& pred, const Value& to)
|
||||
: m_pred(pred), m_to(to)
|
||||
{
|
||||
}
|
||||
replace_value_if(const Pred& pred, const Value& to)
|
||||
: m_pred(pred), m_to(to)
|
||||
{
|
||||
}
|
||||
|
||||
const Value& operator()(const Value& x) const
|
||||
{
|
||||
return m_pred(x) ? m_to : x;
|
||||
}
|
||||
const Value& operator()(const Value& x) const
|
||||
{
|
||||
return m_pred(x) ? m_to : x;
|
||||
}
|
||||
|
||||
private:
|
||||
Pred m_pred;
|
||||
Value m_to;
|
||||
};
|
||||
private:
|
||||
Pred m_pred;
|
||||
Value m_to;
|
||||
};
|
||||
|
||||
template< class Pred, class R >
|
||||
class replace_if_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
|
||||
{
|
||||
private:
|
||||
typedef replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
|
||||
template< class Pred, class R >
|
||||
class replace_if_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > >
|
||||
{
|
||||
private:
|
||||
typedef replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type > Fn;
|
||||
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator<
|
||||
replace_value_if< Pred, BOOST_DEDUCED_TYPENAME range_value<R>::type >,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type > > base_t;
|
||||
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME range_value<R>::type value_type;
|
||||
|
||||
replace_if_range( R& r, const Pred& pred, value_type to )
|
||||
: base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
|
||||
make_transform_iterator( boost::end(r), Fn(pred, to) ) )
|
||||
{ }
|
||||
};
|
||||
replace_if_range( R& r, const Pred& pred, value_type to )
|
||||
: base_t( make_transform_iterator( boost::begin(r), Fn(pred, to) ),
|
||||
make_transform_iterator( boost::end(r), Fn(pred, to) ) )
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class Pred, class T >
|
||||
class replace_if_holder
|
||||
{
|
||||
public:
|
||||
replace_if_holder( const Pred& pred, const T& to )
|
||||
: m_pred(pred), m_to(to)
|
||||
{ }
|
||||
template< class Pred, class T >
|
||||
class replace_if_holder
|
||||
{
|
||||
public:
|
||||
replace_if_holder( const Pred& pred, const T& to )
|
||||
: m_pred(pred), m_to(to)
|
||||
{ }
|
||||
|
||||
const Pred& pred() const { return m_pred; }
|
||||
const T& to() const { return m_to; }
|
||||
const Pred& pred() const { return m_pred; }
|
||||
const T& to() const { return m_to; }
|
||||
|
||||
private:
|
||||
Pred m_pred;
|
||||
T m_to;
|
||||
};
|
||||
private:
|
||||
Pred m_pred;
|
||||
T m_to;
|
||||
};
|
||||
|
||||
template< class Pred, class InputRng >
|
||||
inline replace_if_range<Pred, InputRng>
|
||||
operator|( InputRng& r,
|
||||
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
|
||||
}
|
||||
template< class Pred, class InputRng >
|
||||
inline replace_if_range<Pred, InputRng>
|
||||
operator|( InputRng& r,
|
||||
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_if_range<Pred, InputRng>(r, f.pred(), f.to());
|
||||
}
|
||||
|
||||
template< class Pred, class InputRng >
|
||||
inline replace_if_range<Pred, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
|
||||
}
|
||||
} // 'range_detail'
|
||||
template< class Pred, class InputRng >
|
||||
inline replace_if_range<Pred, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const replace_if_holder<Pred, BOOST_DEDUCED_TYPENAME range_value<InputRng>::type>& f )
|
||||
{
|
||||
return replace_if_range<Pred, const InputRng>(r, f.pred(), f.to());
|
||||
}
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::replace_if_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder2TU<range_detail::replace_if_holder>
|
||||
replaced_if =
|
||||
range_detail::forwarder2TU<range_detail::replace_if_holder>();
|
||||
}
|
||||
|
||||
template<class Pred, class InputRange>
|
||||
inline replace_if_range<Pred, InputRange>
|
||||
replace_if(InputRange& rng, Pred pred,
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder2TU<range_detail::replace_if_holder>
|
||||
replaced_if =
|
||||
range_detail::forwarder2TU<range_detail::replace_if_holder>();
|
||||
}
|
||||
|
||||
template<class Pred, class InputRange>
|
||||
inline replace_if_range<Pred, InputRange>
|
||||
replace_if(InputRange& rng, Pred pred,
|
||||
BOOST_DEDUCED_TYPENAME range_value<InputRange>::type to)
|
||||
{
|
||||
return range_detail::replace_if_range<Pred, InputRange>(rng, pred, to);
|
||||
}
|
||||
{
|
||||
return range_detail::replace_if_range<Pred, InputRange>(rng, pred, to);
|
||||
}
|
||||
|
||||
template<class Pred, class InputRange>
|
||||
inline replace_if_range<Pred, const InputRange>
|
||||
replace_if(const InputRange& rng, Pred pred,
|
||||
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
|
||||
{
|
||||
return range_detail::replace_if_range<Pred, const InputRange>(rng, pred, to);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
template<class Pred, class InputRange>
|
||||
inline replace_if_range<Pred, const InputRange>
|
||||
replace_if(const InputRange& rng, Pred pred,
|
||||
BOOST_DEDUCED_TYPENAME range_value<const InputRange>::type to)
|
||||
{
|
||||
return range_detail::replace_if_range<Pred, const InputRange>(rng, pred, to);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
} // 'boost'
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -16,75 +16,75 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template< class R >
|
||||
struct reverse_range :
|
||||
public boost::iterator_range<
|
||||
boost::reverse_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::reverse_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
base;
|
||||
|
||||
public:
|
||||
typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
|
||||
namespace range_detail
|
||||
{
|
||||
template< class R >
|
||||
struct reverse_range :
|
||||
public boost::iterator_range<
|
||||
boost::reverse_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::reverse_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
base;
|
||||
|
||||
public:
|
||||
typedef boost::reverse_iterator<BOOST_DEDUCED_TYPENAME range_iterator<R>::type> iterator;
|
||||
|
||||
reverse_range( R& r )
|
||||
: base( iterator(boost::end(r)), iterator(boost::begin(r)) )
|
||||
{ }
|
||||
};
|
||||
reverse_range( R& r )
|
||||
: base( iterator(boost::end(r)), iterator(boost::begin(r)) )
|
||||
{ }
|
||||
};
|
||||
|
||||
struct reverse_forwarder {};
|
||||
|
||||
template< class BidirectionalRng >
|
||||
inline reverse_range<BidirectionalRng>
|
||||
operator|( BidirectionalRng& r, reverse_forwarder )
|
||||
{
|
||||
return reverse_range<BidirectionalRng>( r );
|
||||
}
|
||||
|
||||
template< class BidirectionalRng >
|
||||
inline reverse_range<const BidirectionalRng>
|
||||
operator|( const BidirectionalRng& r, reverse_forwarder )
|
||||
{
|
||||
return reverse_range<const BidirectionalRng>( r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::reverse_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::reverse_forwarder reversed =
|
||||
range_detail::reverse_forwarder();
|
||||
}
|
||||
|
||||
template<class BidirectionalRange>
|
||||
inline reverse_range<BidirectionalRange>
|
||||
reverse(BidirectionalRange& rng)
|
||||
{
|
||||
return reverse_range<BidirectionalRange>(rng);
|
||||
}
|
||||
|
||||
template<class BidirectionalRange>
|
||||
inline reverse_range<const BidirectionalRange>
|
||||
reverse(const BidirectionalRange& rng)
|
||||
{
|
||||
return reverse_range<const BidirectionalRange>(rng);
|
||||
struct reverse_forwarder {};
|
||||
|
||||
template< class BidirectionalRng >
|
||||
inline reverse_range<BidirectionalRng>
|
||||
operator|( BidirectionalRng& r, reverse_forwarder )
|
||||
{
|
||||
return reverse_range<BidirectionalRng>( r );
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
|
||||
template< class BidirectionalRng >
|
||||
inline reverse_range<const BidirectionalRng>
|
||||
operator|( const BidirectionalRng& r, reverse_forwarder )
|
||||
{
|
||||
return reverse_range<const BidirectionalRng>( r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::reverse_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::reverse_forwarder reversed =
|
||||
range_detail::reverse_forwarder();
|
||||
}
|
||||
|
||||
template<class BidirectionalRange>
|
||||
inline reverse_range<BidirectionalRange>
|
||||
reverse(BidirectionalRange& rng)
|
||||
{
|
||||
return reverse_range<BidirectionalRange>(rng);
|
||||
}
|
||||
|
||||
template<class BidirectionalRange>
|
||||
inline reverse_range<const BidirectionalRange>
|
||||
reverse(const BidirectionalRange& rng)
|
||||
{
|
||||
return reverse_range<const BidirectionalRange>(rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
} // 'boost'
|
||||
|
||||
#endif
|
||||
|
||||
@@ -18,132 +18,132 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
|
||||
template<typename BaseIterator>
|
||||
class strided_iterator
|
||||
: public iterator_adaptor<
|
||||
strided_iterator<BaseIterator>,
|
||||
BaseIterator>
|
||||
{
|
||||
friend class iterator_core_access;
|
||||
template<typename BaseIterator>
|
||||
class strided_iterator
|
||||
: public iterator_adaptor<
|
||||
strided_iterator<BaseIterator>,
|
||||
BaseIterator>
|
||||
{
|
||||
friend class iterator_core_access;
|
||||
|
||||
typedef iterator_adaptor<strided_iterator<BaseIterator>, BaseIterator> super_t;
|
||||
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
|
||||
|
||||
strided_iterator() : m_stride() { }
|
||||
|
||||
strided_iterator(const strided_iterator& other)
|
||||
: super_t(other), m_stride(other.m_stride) { }
|
||||
|
||||
explicit strided_iterator(BaseIterator base_it, difference_type stride)
|
||||
: super_t(base_it), m_stride(stride) { }
|
||||
|
||||
strided_iterator&
|
||||
operator=(const strided_iterator& other)
|
||||
{
|
||||
super_t::operator=(other);
|
||||
|
||||
// Is the interoperation of the stride safe?
|
||||
m_stride = other.m_stride;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void increment() { std::advance(this->base_reference(), m_stride); }
|
||||
|
||||
void decrement() { std::advance(this->base_reference(), -m_stride); }
|
||||
|
||||
void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); }
|
||||
|
||||
difference_type
|
||||
distance_to(const strided_iterator& other) const
|
||||
{
|
||||
return std::distance(this->base_reference(), other.base_reference()) / m_stride;
|
||||
}
|
||||
typedef iterator_adaptor<strided_iterator<BaseIterator>, BaseIterator> super_t;
|
||||
|
||||
public:
|
||||
typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
|
||||
|
||||
strided_iterator() : m_stride() { }
|
||||
|
||||
strided_iterator(const strided_iterator& other)
|
||||
: super_t(other), m_stride(other.m_stride) { }
|
||||
|
||||
explicit strided_iterator(BaseIterator base_it, difference_type stride)
|
||||
: super_t(base_it), m_stride(stride) { }
|
||||
|
||||
strided_iterator&
|
||||
operator=(const strided_iterator& other)
|
||||
{
|
||||
super_t::operator=(other);
|
||||
|
||||
// Is the interoperation of the stride safe?
|
||||
m_stride = other.m_stride;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void increment() { std::advance(this->base_reference(), m_stride); }
|
||||
|
||||
void decrement() { std::advance(this->base_reference(), -m_stride); }
|
||||
|
||||
void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); }
|
||||
|
||||
difference_type
|
||||
distance_to(const strided_iterator& other) const
|
||||
{
|
||||
return std::distance(this->base_reference(), other.base_reference()) / m_stride;
|
||||
}
|
||||
|
||||
// Using the compiler generated copy constructor and
|
||||
// and assignment operator
|
||||
|
||||
private:
|
||||
difference_type m_stride;
|
||||
};
|
||||
|
||||
template<class BaseIterator> inline
|
||||
strided_iterator<BaseIterator>
|
||||
make_strided_iterator(
|
||||
const BaseIterator& first,
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride)
|
||||
{
|
||||
return strided_iterator<BaseIterator>(first, stride);
|
||||
}
|
||||
// Using the compiler generated copy constructor and
|
||||
// and assignment operator
|
||||
|
||||
private:
|
||||
difference_type m_stride;
|
||||
};
|
||||
|
||||
template<class BaseIterator> inline
|
||||
strided_iterator<BaseIterator>
|
||||
make_strided_iterator(
|
||||
const BaseIterator& first,
|
||||
BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride)
|
||||
{
|
||||
return strided_iterator<BaseIterator>(first, stride);
|
||||
}
|
||||
|
||||
template< class Rng >
|
||||
class strided_range
|
||||
: public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
|
||||
{
|
||||
typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type;
|
||||
typedef iterator_range<iter_type> super_t;
|
||||
public:
|
||||
template< typename Difference >
|
||||
strided_range(Difference stride, Rng& rng)
|
||||
template< class Rng >
|
||||
class strided_range
|
||||
: public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> >
|
||||
{
|
||||
typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type;
|
||||
typedef iterator_range<iter_type> super_t;
|
||||
public:
|
||||
template< typename Difference >
|
||||
strided_range(Difference stride, Rng& rng)
|
||||
: super_t(make_strided_iterator(boost::begin(rng), stride),
|
||||
make_strided_iterator(boost::end(rng), stride))
|
||||
{
|
||||
}
|
||||
};
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
template<class Difference>
|
||||
class strided_holder : public holder<Difference>
|
||||
{
|
||||
public:
|
||||
strided_holder(Difference value) : holder<Difference>(value) {}
|
||||
};
|
||||
template<class Difference>
|
||||
class strided_holder : public holder<Difference>
|
||||
{
|
||||
public:
|
||||
strided_holder(Difference value) : holder<Difference>(value) {}
|
||||
};
|
||||
|
||||
template<class Rng, class Difference>
|
||||
inline strided_range<Rng>
|
||||
operator|(Rng& rng, const strided_holder<Difference>& stride)
|
||||
{
|
||||
return strided_range<Rng>(stride.val, rng);
|
||||
}
|
||||
template<class Rng, class Difference>
|
||||
inline strided_range<Rng>
|
||||
operator|(Rng& rng, const strided_holder<Difference>& stride)
|
||||
{
|
||||
return strided_range<Rng>(stride.val, rng);
|
||||
}
|
||||
|
||||
template<class Rng, class Difference>
|
||||
inline strided_range<const Rng>
|
||||
operator|(const Rng& rng, const strided_holder<Difference>& stride)
|
||||
{
|
||||
return strided_range<const Rng>(stride.val, rng);
|
||||
}
|
||||
template<class Rng, class Difference>
|
||||
inline strided_range<const Rng>
|
||||
operator|(const Rng& rng, const strided_holder<Difference>& stride)
|
||||
{
|
||||
return strided_range<const Rng>(stride.val, rng);
|
||||
}
|
||||
|
||||
} // namespace range_detail
|
||||
|
||||
using range_detail::strided_range;
|
||||
} // namespace range_detail
|
||||
|
||||
using range_detail::strided_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::strided_holder>
|
||||
strided = range_detail::forwarder<range_detail::strided_holder>();
|
||||
}
|
||||
|
||||
template<class Range, class Difference>
|
||||
inline strided_range<Range>
|
||||
stride(Range& rng, Difference step)
|
||||
{
|
||||
return strided_range<Range>(step, rng);
|
||||
}
|
||||
|
||||
template<class Range, class Difference>
|
||||
inline strided_range<const Range>
|
||||
stride(const Range& rng, Difference step)
|
||||
{
|
||||
return strided_range<const Range>(step, rng);
|
||||
namespace adaptors
|
||||
{
|
||||
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::strided_holder>
|
||||
strided = range_detail::forwarder<range_detail::strided_holder>();
|
||||
}
|
||||
|
||||
} // namespace 'adaptors'
|
||||
template<class Range, class Difference>
|
||||
inline strided_range<Range>
|
||||
stride(Range& rng, Difference step)
|
||||
{
|
||||
return strided_range<Range>(step, rng);
|
||||
}
|
||||
|
||||
template<class Range, class Difference>
|
||||
inline strided_range<const Range>
|
||||
stride(const Range& rng, Difference step)
|
||||
{
|
||||
return strided_range<const Range>(step, rng);
|
||||
}
|
||||
|
||||
} // namespace 'adaptors'
|
||||
} // namespace 'boost'
|
||||
|
||||
#endif
|
||||
|
||||
@@ -16,122 +16,122 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
|
||||
template< class R >
|
||||
struct token_range :
|
||||
public boost::iterator_range<
|
||||
boost::regex_token_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef
|
||||
boost::regex_token_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
regex_iter;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME regex_iter::regex_type
|
||||
regex_type;
|
||||
|
||||
typedef boost::iterator_range<regex_iter>
|
||||
base;
|
||||
template< class R >
|
||||
struct token_range :
|
||||
public boost::iterator_range<
|
||||
boost::regex_token_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef
|
||||
boost::regex_token_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
regex_iter;
|
||||
|
||||
typedef BOOST_DEDUCED_TYPENAME regex_iter::regex_type
|
||||
regex_type;
|
||||
|
||||
typedef boost::iterator_range<regex_iter>
|
||||
base;
|
||||
|
||||
public:
|
||||
template< class Regex, class Submatch, class Flag >
|
||||
token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
|
||||
: base( regex_iter( boost::begin(r), boost::end(r),
|
||||
regex_type(re), sub, f ),
|
||||
regex_iter() )
|
||||
{ }
|
||||
};
|
||||
public:
|
||||
template< class Regex, class Submatch, class Flag >
|
||||
token_range( R& r, const Regex& re, const Submatch& sub, Flag f )
|
||||
: base( regex_iter( boost::begin(r), boost::end(r),
|
||||
regex_type(re), sub, f ),
|
||||
regex_iter() )
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T, class U, class V >
|
||||
struct regex_holder
|
||||
{
|
||||
const T& re;
|
||||
const U& sub;
|
||||
V f;
|
||||
template< class T, class U, class V >
|
||||
struct regex_holder
|
||||
{
|
||||
const T& re;
|
||||
const U& sub;
|
||||
V f;
|
||||
|
||||
regex_holder( const T& rex, const U& subm, V flag ) :
|
||||
re(rex), sub(subm), f(flag)
|
||||
{ }
|
||||
private:
|
||||
// Not assignable
|
||||
void operator=(const regex_holder&);
|
||||
};
|
||||
regex_holder( const T& rex, const U& subm, V flag ) :
|
||||
re(rex), sub(subm), f(flag)
|
||||
{ }
|
||||
private:
|
||||
// Not assignable
|
||||
void operator=(const regex_holder&);
|
||||
};
|
||||
|
||||
struct regex_forwarder
|
||||
{
|
||||
template< class Regex >
|
||||
regex_holder<Regex,int,regex_constants::match_flag_type>
|
||||
operator()( const Regex& re,
|
||||
int submatch = 0,
|
||||
regex_constants::match_flag_type f =
|
||||
regex_constants::match_default ) const
|
||||
{
|
||||
return regex_holder<Regex,int,
|
||||
regex_constants::match_flag_type>( re, submatch, f );
|
||||
}
|
||||
|
||||
template< class Regex, class Submatch >
|
||||
regex_holder<Regex,Submatch,regex_constants::match_flag_type>
|
||||
operator()( const Regex& re,
|
||||
const Submatch& sub,
|
||||
regex_constants::match_flag_type f =
|
||||
regex_constants::match_default ) const
|
||||
{
|
||||
return regex_holder<Regex,Submatch,
|
||||
regex_constants::match_flag_type>( re, sub, f );
|
||||
}
|
||||
};
|
||||
|
||||
template< class BidirectionalRng, class R, class S, class F >
|
||||
inline token_range<BidirectionalRng>
|
||||
operator|( BidirectionalRng& r,
|
||||
const regex_holder<R,S,F>& f )
|
||||
{
|
||||
return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
|
||||
}
|
||||
struct regex_forwarder
|
||||
{
|
||||
template< class Regex >
|
||||
regex_holder<Regex,int,regex_constants::match_flag_type>
|
||||
operator()( const Regex& re,
|
||||
int submatch = 0,
|
||||
regex_constants::match_flag_type f =
|
||||
regex_constants::match_default ) const
|
||||
{
|
||||
return regex_holder<Regex,int,
|
||||
regex_constants::match_flag_type>( re, submatch, f );
|
||||
}
|
||||
|
||||
template< class Regex, class Submatch >
|
||||
regex_holder<Regex,Submatch,regex_constants::match_flag_type>
|
||||
operator()( const Regex& re,
|
||||
const Submatch& sub,
|
||||
regex_constants::match_flag_type f =
|
||||
regex_constants::match_default ) const
|
||||
{
|
||||
return regex_holder<Regex,Submatch,
|
||||
regex_constants::match_flag_type>( re, sub, f );
|
||||
}
|
||||
};
|
||||
|
||||
template< class BidirectionalRng, class R, class S, class F >
|
||||
inline token_range<BidirectionalRng>
|
||||
operator|( BidirectionalRng& r,
|
||||
const regex_holder<R,S,F>& f )
|
||||
{
|
||||
return token_range<BidirectionalRng>( r, f.re, f.sub, f.f );
|
||||
}
|
||||
|
||||
template< class BidirectionalRng, class R, class S, class F >
|
||||
inline token_range<const BidirectionalRng>
|
||||
operator|( const BidirectionalRng& r,
|
||||
const regex_holder<R,S,F>& f )
|
||||
{
|
||||
return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
template< class BidirectionalRng, class R, class S, class F >
|
||||
inline token_range<const BidirectionalRng>
|
||||
operator|( const BidirectionalRng& r,
|
||||
const regex_holder<R,S,F>& f )
|
||||
{
|
||||
return token_range<const BidirectionalRng>( r, f.re, f.sub, f.f );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::token_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::regex_forwarder tokenized =
|
||||
range_detail::regex_forwarder();
|
||||
}
|
||||
|
||||
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
|
||||
inline token_range<BidirectionalRange>
|
||||
tokenize(BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
|
||||
{
|
||||
return token_range<BidirectionalRange>(rng, reg, sub, f);
|
||||
}
|
||||
|
||||
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
|
||||
inline token_range<const BidirectionalRange>
|
||||
tokenize(const BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
|
||||
{
|
||||
return token_range<const BidirectionalRange>(rng, reg, sub, f);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::regex_forwarder tokenized =
|
||||
range_detail::regex_forwarder();
|
||||
}
|
||||
|
||||
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
|
||||
inline token_range<BidirectionalRange>
|
||||
tokenize(BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
|
||||
{
|
||||
return token_range<BidirectionalRange>(rng, reg, sub, f);
|
||||
}
|
||||
|
||||
template<class BidirectionalRange, class Regex, class Submatch, class Flag>
|
||||
inline token_range<const BidirectionalRange>
|
||||
tokenize(const BidirectionalRange& rng, const Regex& reg, const Submatch& sub, Flag f)
|
||||
{
|
||||
return token_range<const BidirectionalRange>(rng, reg, sub, f);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -17,87 +17,87 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
|
||||
template< class F, class R >
|
||||
struct transform_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator< F,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator< F,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
base;
|
||||
template< class F, class R >
|
||||
struct transform_range :
|
||||
public boost::iterator_range<
|
||||
boost::transform_iterator< F,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
{
|
||||
private:
|
||||
typedef boost::iterator_range<
|
||||
boost::transform_iterator< F,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<R>::type
|
||||
>
|
||||
>
|
||||
base;
|
||||
|
||||
public:
|
||||
typedef F transform_fn_type;
|
||||
typedef R source_range_type;
|
||||
|
||||
transform_range( F f, R& r )
|
||||
: base( make_transform_iterator( boost::begin(r), f ),
|
||||
make_transform_iterator( boost::end(r), f ) )
|
||||
|
||||
{ }
|
||||
};
|
||||
public:
|
||||
typedef F transform_fn_type;
|
||||
typedef R source_range_type;
|
||||
|
||||
transform_range( F f, R& r )
|
||||
: base( make_transform_iterator( boost::begin(r), f ),
|
||||
make_transform_iterator( boost::end(r), f ) )
|
||||
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class T >
|
||||
struct transform_holder : holder<T>
|
||||
{
|
||||
transform_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class InputRng, class UnaryFunction >
|
||||
inline transform_range<UnaryFunction,InputRng>
|
||||
operator|( InputRng& r,
|
||||
const transform_holder<UnaryFunction>& f )
|
||||
{
|
||||
return transform_range<UnaryFunction,InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
template< class InputRng, class UnaryFunction >
|
||||
inline transform_range<UnaryFunction, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const transform_holder<UnaryFunction>& f )
|
||||
{
|
||||
return transform_range<UnaryFunction, const InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
template< class T >
|
||||
struct transform_holder : holder<T>
|
||||
{
|
||||
transform_holder( T r ) : holder<T>(r)
|
||||
{ }
|
||||
};
|
||||
|
||||
template< class InputRng, class UnaryFunction >
|
||||
inline transform_range<UnaryFunction,InputRng>
|
||||
operator|( InputRng& r,
|
||||
const transform_holder<UnaryFunction>& f )
|
||||
{
|
||||
return transform_range<UnaryFunction,InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
template< class InputRng, class UnaryFunction >
|
||||
inline transform_range<UnaryFunction, const InputRng>
|
||||
operator|( const InputRng& r,
|
||||
const transform_holder<UnaryFunction>& f )
|
||||
{
|
||||
return transform_range<UnaryFunction, const InputRng>( f.val, r );
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::transform_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::transform_holder>
|
||||
transformed =
|
||||
using range_detail::transform_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::forwarder<range_detail::transform_holder>
|
||||
transformed =
|
||||
range_detail::forwarder<range_detail::transform_holder>();
|
||||
}
|
||||
|
||||
template<class UnaryFunction, class InputRange>
|
||||
inline transform_range<UnaryFunction, InputRange>
|
||||
transform(InputRange& rng, UnaryFunction fn)
|
||||
{
|
||||
return transform_range<UnaryFunction, InputRange>(fn, rng);
|
||||
}
|
||||
|
||||
template<class UnaryFunction, class InputRange>
|
||||
inline transform_range<UnaryFunction, const InputRange>
|
||||
transform(const InputRange& rng, UnaryFunction fn)
|
||||
{
|
||||
return transform_range<UnaryFunction, const InputRange>(fn, rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
template<class UnaryFunction, class InputRange>
|
||||
inline transform_range<UnaryFunction, InputRange>
|
||||
transform(InputRange& rng, UnaryFunction fn)
|
||||
{
|
||||
return transform_range<UnaryFunction, InputRange>(fn, rng);
|
||||
}
|
||||
|
||||
template<class UnaryFunction, class InputRange>
|
||||
inline transform_range<UnaryFunction, const InputRange>
|
||||
transform(const InputRange& rng, UnaryFunction fn)
|
||||
{
|
||||
return transform_range<UnaryFunction, const InputRange>(fn, rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -16,74 +16,74 @@
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace range_detail
|
||||
{
|
||||
struct unique_forwarder { };
|
||||
namespace range_detail
|
||||
{
|
||||
struct unique_forwarder { };
|
||||
|
||||
struct unique_not_equal_to
|
||||
{
|
||||
typedef bool result_type;
|
||||
struct unique_not_equal_to
|
||||
{
|
||||
typedef bool result_type;
|
||||
|
||||
template< class T >
|
||||
bool operator()( const T& l, const T& r ) const
|
||||
{
|
||||
return !(l == r);
|
||||
}
|
||||
};
|
||||
template< class T >
|
||||
bool operator()( const T& l, const T& r ) const
|
||||
{
|
||||
return !(l == r);
|
||||
}
|
||||
};
|
||||
|
||||
template<class ForwardRng>
|
||||
class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
|
||||
{
|
||||
typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
|
||||
public:
|
||||
explicit unique_range(ForwardRng& rng)
|
||||
: base(unique_not_equal_to(), rng)
|
||||
{
|
||||
}
|
||||
};
|
||||
template<class ForwardRng>
|
||||
class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
|
||||
{
|
||||
typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
|
||||
public:
|
||||
explicit unique_range(ForwardRng& rng)
|
||||
: base(unique_not_equal_to(), rng)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
template< class ForwardRng >
|
||||
inline unique_range<ForwardRng>
|
||||
operator|( ForwardRng& r,
|
||||
unique_forwarder )
|
||||
{
|
||||
return unique_range<ForwardRng>(r);
|
||||
}
|
||||
|
||||
template< class ForwardRng >
|
||||
inline unique_range<const ForwardRng>
|
||||
operator|( const ForwardRng& r,
|
||||
unique_forwarder )
|
||||
{
|
||||
return unique_range<const ForwardRng>(r);
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::unique_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::unique_forwarder uniqued =
|
||||
range_detail::unique_forwarder();
|
||||
}
|
||||
|
||||
template<class ForwardRange>
|
||||
inline unique_range<ForwardRange>
|
||||
unique(ForwardRange& rng)
|
||||
{
|
||||
return unique_range<ForwardRange>(rng);
|
||||
}
|
||||
|
||||
template<class ForwardRange>
|
||||
inline unique_range<const ForwardRange>
|
||||
unique(const ForwardRange& rng)
|
||||
{
|
||||
return unique_range<const ForwardRange>(rng);
|
||||
template< class ForwardRng >
|
||||
inline unique_range<ForwardRng>
|
||||
operator|( ForwardRng& r,
|
||||
unique_forwarder )
|
||||
{
|
||||
return unique_range<ForwardRng>(r);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
template< class ForwardRng >
|
||||
inline unique_range<const ForwardRng>
|
||||
operator|( const ForwardRng& r,
|
||||
unique_forwarder )
|
||||
{
|
||||
return unique_range<const ForwardRng>(r);
|
||||
}
|
||||
|
||||
} // 'range_detail'
|
||||
|
||||
using range_detail::unique_range;
|
||||
|
||||
namespace adaptors
|
||||
{
|
||||
namespace
|
||||
{
|
||||
const range_detail::unique_forwarder uniqued =
|
||||
range_detail::unique_forwarder();
|
||||
}
|
||||
|
||||
template<class ForwardRange>
|
||||
inline unique_range<ForwardRange>
|
||||
unique(ForwardRange& rng)
|
||||
{
|
||||
return unique_range<ForwardRange>(rng);
|
||||
}
|
||||
|
||||
template<class ForwardRange>
|
||||
inline unique_range<const ForwardRange>
|
||||
unique(const ForwardRange& rng)
|
||||
{
|
||||
return unique_range<const ForwardRange>(rng);
|
||||
}
|
||||
} // 'adaptors'
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -22,8 +22,9 @@
|
||||
#include <boost/range/adaptor/replaced_if.hpp>
|
||||
#include <boost/range/adaptor/reversed.hpp>
|
||||
#include <boost/range/adaptor/sliced.hpp>
|
||||
#include <boost/range/adaptor/strided.hpp>
|
||||
#include <boost/range/adaptor/tokenized.hpp>
|
||||
#include <boost/range/adaptor/transformed.hpp>
|
||||
#include <boost/range/adaptor/uniqued.hpp>
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -20,7 +20,7 @@ namespace boost
|
||||
{
|
||||
// An implementation of equality comparison that is optimized for iterator
|
||||
// traversal categories less than RandomAccessTraversal.
|
||||
template< class SinglePassTraversalReadableIterator1,
|
||||
template< class SinglePassTraversalReadableIterator1,
|
||||
class SinglePassTraversalReadableIterator2,
|
||||
class IteratorCategoryTag1,
|
||||
class IteratorCategoryTag2 >
|
||||
|
||||
@@ -33,15 +33,6 @@ inline ForwardRange& generate( ForwardRange& rng, Generator gen )
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< class ForwardRange, class Generator >
|
||||
inline const ForwardRange& generate(const ForwardRange& rng, Generator gen)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
std::generate(boost::begin(rng), boost::end(rng), gen);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::generate;
|
||||
} // namespace boost
|
||||
|
||||
@@ -27,34 +27,20 @@ namespace boost
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre Compare is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void push_heap(RandomAccessRange& rng)
|
||||
inline RandomAccessRange& push_heap(RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::push_heap(boost::begin(rng), boost::end(rng));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void push_heap(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::push_heap(boost::begin(rng), boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void push_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::push_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \brief template function pop_heap
|
||||
@@ -64,34 +50,20 @@ inline void push_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre Compare is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void pop_heap(RandomAccessRange& rng)
|
||||
inline RandomAccessRange& pop_heap(RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::pop_heap(boost::begin(rng), boost::end(rng));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void pop_heap(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::pop_heap(boost::begin(rng),boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void pop_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \brief template function make_heap
|
||||
@@ -101,34 +73,20 @@ inline void pop_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre Compare is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void make_heap(RandomAccessRange& rng)
|
||||
inline RandomAccessRange& make_heap(RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::make_heap(boost::begin(rng), boost::end(rng));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void make_heap(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::make_heap(boost::begin(rng),boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void make_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::make_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \brief template function sort_heap
|
||||
@@ -138,34 +96,20 @@ inline void make_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre Compare is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void sort_heap(RandomAccessRange& rng)
|
||||
inline RandomAccessRange& sort_heap(RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::sort_heap(boost::begin(rng), boost::end(rng));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void sort_heap(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::sort_heap(boost::begin(rng), boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void sort_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Compare>
|
||||
inline void sort_heap(const RandomAccessRange& rng, Compare comp_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
|
||||
@@ -27,40 +27,44 @@ namespace boost
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void nth_element(RandomAccessRange& rng,
|
||||
inline RandomAccessRange& nth_element(RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::nth_element(boost::begin(rng), nth, boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void nth_element(const RandomAccessRange& rng,
|
||||
inline const RandomAccessRange& nth_element(const RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::nth_element(boost::begin(rng),nth,boost::end(rng));
|
||||
std::nth_element(boost::begin(rng), nth, boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline void nth_element(RandomAccessRange& rng,
|
||||
inline RandomAccessRange& nth_element(RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth,
|
||||
BinaryPredicate sort_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline void nth_element(const RandomAccessRange& rng,
|
||||
inline const RandomAccessRange& nth_element(const RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth,
|
||||
BinaryPredicate sort_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::nth_element(boost::begin(rng),nth,boost::end(rng), sort_pred);
|
||||
std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
|
||||
@@ -27,41 +27,24 @@ namespace boost
|
||||
/// \pre RandomAccessRange is a model of the RandomAccessRangeConcept
|
||||
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
|
||||
template<class RandomAccessRange>
|
||||
inline void partial_sort(RandomAccessRange& rng,
|
||||
inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline void partial_sort(const RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::partial_sort(boost::begin(rng), middle, boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline void partial_sort(RandomAccessRange& rng,
|
||||
inline RandomAccessRange& partial_sort(RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle,
|
||||
BinaryPredicate sort_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> ));
|
||||
std::partial_sort(boost::begin(rng), middle, boost::end(rng),
|
||||
sort_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline void partial_sort(const RandomAccessRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle,
|
||||
BinaryPredicate sort_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
|
||||
@@ -28,30 +28,24 @@ namespace boost
|
||||
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
|
||||
/// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept
|
||||
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
|
||||
template<typename SinglePassRange, typename RandomAccessRange>
|
||||
inline typename range_iterator<RandomAccessRange>::type
|
||||
template<class SinglePassRange, class RandomAccessRange>
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
|
||||
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2)
|
||||
{
|
||||
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));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<typename SinglePassRange, typename RandomAccessRange,
|
||||
typename BinaryPredicate>
|
||||
inline typename range_iterator<RandomAccessRange>::type
|
||||
template<class SinglePassRange, class RandomAccessRange,
|
||||
class BinaryPredicate>
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type
|
||||
partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2,
|
||||
BinaryPredicate pred)
|
||||
{
|
||||
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);
|
||||
|
||||
@@ -34,15 +34,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
|
||||
return std::partition(boost::begin(rng),boost::end(rng),pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class ForwardRange, class UnaryPredicate>
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
|
||||
partition(const ForwardRange& rng, UnaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return std::partition(boost::begin(rng),boost::end(rng),pred);
|
||||
}
|
||||
|
||||
// range_return overloads
|
||||
|
||||
/// \overload
|
||||
@@ -56,17 +47,6 @@ partition(ForwardRange& rng, UnaryPredicate pred)
|
||||
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, class ForwardRange,
|
||||
class UnaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
|
||||
partition(const ForwardRange& rng, UnaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return boost::range_return<const ForwardRange,re>::
|
||||
pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng);
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::partition;
|
||||
} // namespace boost
|
||||
|
||||
@@ -34,15 +34,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::random_shuffle(boost::begin(rng),boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Generator>
|
||||
inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
|
||||
@@ -52,15 +43,6 @@ inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class Generator>
|
||||
inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::random_shuffle(boost::begin(rng), boost::end(rng), gen);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::random_shuffle;
|
||||
} // namespace boost
|
||||
|
||||
@@ -34,15 +34,6 @@ remove(ForwardRange& rng, const Value& val)
|
||||
return std::remove(boost::begin(rng),boost::end(rng),val);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< class ForwardRange, class Value >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
|
||||
remove(const ForwardRange& rng, const Value& val)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return std::remove(boost::begin(rng),boost::end(rng),val);
|
||||
}
|
||||
|
||||
// range_return overloads
|
||||
|
||||
/// \overload
|
||||
@@ -56,17 +47,6 @@ remove(ForwardRange& rng, const Value& val)
|
||||
rng);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, class ForwardRange, class Value >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
|
||||
remove(const ForwardRange& rng, const Value& val)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return range_return<const ForwardRange,re>::pack(
|
||||
std::remove(boost::begin(rng), boost::end(rng), val),
|
||||
rng);
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::remove;
|
||||
} // namespace boost
|
||||
|
||||
@@ -31,7 +31,7 @@ namespace boost
|
||||
remove_copy_if(SinglePassRange& rng, OutputIterator out_it, Predicate pred)
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
|
||||
return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -35,15 +35,6 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
|
||||
return std::remove_if(boost::begin(rng), boost::end(rng), pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< class ForwardRange, class UnaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type
|
||||
remove_if(const ForwardRange& rng, UnaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return std::remove_if(boost::begin(rng),boost::end(rng),pred);
|
||||
}
|
||||
|
||||
// range_return overloads
|
||||
|
||||
/// \overload
|
||||
@@ -57,17 +48,6 @@ remove_if(ForwardRange& rng, UnaryPredicate pred)
|
||||
rng);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, class ForwardRange, class UnaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
|
||||
remove_if(const ForwardRange& rng, UnaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
return range_return<const ForwardRange,re>::pack(
|
||||
std::remove_if(boost::begin(rng), boost::end(rng), pred),
|
||||
rng);
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::remove_if;
|
||||
} // namespace boost
|
||||
|
||||
@@ -35,17 +35,6 @@ replace(ForwardRange& rng, const Value& what,
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< class ForwardRange, class Value >
|
||||
inline const ForwardRange&
|
||||
replace(const ForwardRange& rng, const Value& what,
|
||||
const Value& with_what)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
std::replace(boost::begin(rng), boost::end(rng), what, with_what);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::replace;
|
||||
} // namespace boost;
|
||||
|
||||
@@ -36,17 +36,6 @@ inline ForwardRange&
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< class ForwardRange, class UnaryPredicate, class Value >
|
||||
inline const ForwardRange&
|
||||
replace_if(const ForwardRange& rng, UnaryPredicate pred,
|
||||
const Value& val)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
std::replace_if(boost::begin(rng), boost::end(rng), pred, val);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::replace_if;
|
||||
} // namespace boost
|
||||
|
||||
@@ -34,15 +34,6 @@ inline BidirectionalRange& reverse(BidirectionalRange& rng)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class BidirectionalRange>
|
||||
inline const BidirectionalRange& reverse(const BidirectionalRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> ));
|
||||
std::reverse(boost::begin(rng), boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::reverse;
|
||||
} // namespace boost
|
||||
|
||||
@@ -26,15 +26,7 @@ namespace boost
|
||||
/// range-based version of the reverse_copy std algorithm
|
||||
///
|
||||
/// \pre BidirectionalRange is a model of the BidirectionalRangeConcept
|
||||
template<typename BidirectionalRange, typename OutputIterator>
|
||||
inline OutputIterator reverse_copy(BidirectionalRange& rng, OutputIterator out)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
|
||||
return std::reverse_copy(boost::begin(rng), boost::end(rng), out);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<typename BidirectionalRange, typename OutputIterator>
|
||||
template<class BidirectionalRange, class OutputIterator>
|
||||
inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> ));
|
||||
|
||||
@@ -25,26 +25,15 @@ namespace boost
|
||||
/// range-based version of the rotate std algorithm
|
||||
///
|
||||
/// \pre Rng meets the requirements for a Forward range
|
||||
template<typename ForwardRange>
|
||||
template<class ForwardRange>
|
||||
inline ForwardRange& rotate(ForwardRange& rng,
|
||||
typename range_iterator<ForwardRange>::type middle)
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type middle)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> ));
|
||||
std::rotate(boost::begin(rng), middle, boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<typename ForwardRange>
|
||||
inline const ForwardRange&
|
||||
rotate(const ForwardRange& rng,
|
||||
typename range_iterator<const ForwardRange>::type middle)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
std::rotate(boost::begin(rng), middle, boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::rotate;
|
||||
} // namespace boost
|
||||
|
||||
@@ -28,9 +28,9 @@ namespace boost
|
||||
/// \pre Rng meets the requirements for a Forward range
|
||||
template<typename ForwardRange, typename OutputIterator>
|
||||
inline OutputIterator rotate_copy(
|
||||
const ForwardRange& rng,
|
||||
typename range_iterator<const ForwardRange>::type middle,
|
||||
OutputIterator target
|
||||
const ForwardRange& rng,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle,
|
||||
OutputIterator target
|
||||
)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> ));
|
||||
|
||||
@@ -45,8 +45,8 @@ search(const ForwardRange1& rng1, const ForwardRange2& rng2)
|
||||
{
|
||||
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));
|
||||
return std::search(boost::begin(rng1), boost::end(rng1),
|
||||
boost::begin(rng2), boost::end(rng2));
|
||||
}
|
||||
|
||||
/// \overload
|
||||
@@ -63,13 +63,12 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
|
||||
/// \overload
|
||||
template< class ForwardRange1, class ForwardRange2, class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type
|
||||
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
|
||||
BinaryPredicate pred)
|
||||
search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
|
||||
{
|
||||
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);
|
||||
return std::search(boost::begin(rng1), boost::end(rng1),
|
||||
boost::begin(rng2), boost::end(rng2), pred);
|
||||
}
|
||||
|
||||
// range_return overloads
|
||||
@@ -118,8 +117,7 @@ search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
|
||||
template< range_return_value re, class ForwardRange1, class ForwardRange2,
|
||||
class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type
|
||||
search(const ForwardRange1& rng1, const ForwardRange2& rng2,
|
||||
BinaryPredicate pred)
|
||||
search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> ));
|
||||
|
||||
@@ -31,8 +31,8 @@ namespace boost
|
||||
/// \pre Value is a model of the EqualityComparableConcept
|
||||
/// \pre ForwardRange's value type is a model of the EqualityComparableConcept
|
||||
/// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value
|
||||
template< typename ForwardRange, typename Integer, typename Value >
|
||||
inline typename range_iterator<ForwardRange>::type
|
||||
template< class ForwardRange, class Integer, class Value >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
|
||||
search_n(ForwardRange& rng, Integer count, const Value& value)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
@@ -40,8 +40,8 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< typename ForwardRange, typename Integer, typename Value >
|
||||
inline typename range_iterator<const ForwardRange>::type
|
||||
template< class ForwardRange, class Integer, class Value >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
|
||||
search_n(const ForwardRange& rng, Integer count, const Value& value)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
@@ -49,29 +49,29 @@ search_n(const ForwardRange& rng, Integer count, const Value& value)
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< typename ForwardRange, typename Integer, class Value,
|
||||
typename BinaryPredicate >
|
||||
inline typename range_iterator<ForwardRange>::type
|
||||
template< class ForwardRange, class Integer, class Value,
|
||||
class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type
|
||||
search_n(ForwardRange& rng, Integer count, const Value& value,
|
||||
BinaryPredicate binary_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
|
||||
typename range_value<ForwardRange>::type, const Value&>));
|
||||
BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type, const Value&>));
|
||||
return std::search_n(boost::begin(rng), boost::end(rng),
|
||||
count, value, binary_pred);
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< typename ForwardRange, typename Integer, typename Value,
|
||||
typename BinaryPredicate >
|
||||
inline typename range_iterator<const ForwardRange>::type
|
||||
template< class ForwardRange, class Integer, class Value,
|
||||
class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type
|
||||
search_n(const ForwardRange& rng, Integer count, const Value& value,
|
||||
BinaryPredicate binary_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
|
||||
typename range_value<const ForwardRange>::type, const Value&>));
|
||||
BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type, const Value&>));
|
||||
return std::search_n(boost::begin(rng), boost::end(rng),
|
||||
count, value, binary_pred);
|
||||
}
|
||||
@@ -79,9 +79,9 @@ search_n(const ForwardRange& rng, Integer count, const Value& value,
|
||||
// range_return overloads
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, typename ForwardRange, typename Integer,
|
||||
typename Value >
|
||||
inline typename range_return<ForwardRange,re>::type
|
||||
template< range_return_value re, class ForwardRange, class Integer,
|
||||
class Value >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
|
||||
search_n(ForwardRange& rng, Integer count, const Value& value)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
@@ -92,9 +92,9 @@ search_n(ForwardRange& rng, Integer count, const Value& value)
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, typename ForwardRange, typename Integer,
|
||||
template< range_return_value re, class ForwardRange, class Integer,
|
||||
class Value >
|
||||
inline typename range_return<const ForwardRange,re>::type
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
|
||||
search_n(const ForwardRange& rng, Integer count, const Value& value)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
@@ -105,15 +105,15 @@ search_n(const ForwardRange& rng, Integer count, const Value& value)
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, typename ForwardRange, typename Integer,
|
||||
typename Value, typename BinaryPredicate >
|
||||
inline typename range_return<ForwardRange,re>::type
|
||||
template< range_return_value re, class ForwardRange, class Integer,
|
||||
class Value, class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type
|
||||
search_n(ForwardRange& rng, Integer count, const Value& value,
|
||||
BinaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
|
||||
typename range_value<ForwardRange>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type,
|
||||
const Value&>));
|
||||
return range_return<ForwardRange,re>::
|
||||
pack(std::search_n(boost::begin(rng), boost::end(rng),
|
||||
@@ -122,15 +122,15 @@ search_n(ForwardRange& rng, Integer count, const Value& value,
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template< range_return_value re, typename ForwardRange, typename Integer,
|
||||
typename Value, typename BinaryPredicate >
|
||||
inline typename range_return<const ForwardRange,re>::type
|
||||
template< range_return_value re, class ForwardRange, class Integer,
|
||||
class Value, class BinaryPredicate >
|
||||
inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type
|
||||
search_n(const ForwardRange& rng, Integer count, const Value& value,
|
||||
BinaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>));
|
||||
BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
|
||||
typename range_value<const ForwardRange>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type,
|
||||
const Value&>));
|
||||
return range_return<const ForwardRange,re>::
|
||||
pack(std::search_n(boost::begin(rng), boost::end(rng),
|
||||
|
||||
@@ -34,15 +34,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline const RandomAccessRange& sort(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::sort(boost::begin(rng),boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
|
||||
@@ -52,15 +43,6 @@ inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::sort(boost::begin(rng), boost::end(rng), pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::sort;
|
||||
} // namespace boost
|
||||
|
||||
@@ -34,15 +34,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng)
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange>
|
||||
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::stable_sort(boost::begin(rng), boost::end(rng));
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred)
|
||||
@@ -52,15 +43,6 @@ inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate so
|
||||
return rng;
|
||||
}
|
||||
|
||||
/// \overload
|
||||
template<class RandomAccessRange, class BinaryPredicate>
|
||||
inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> ));
|
||||
std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred);
|
||||
return rng;
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::stable_sort;
|
||||
} // namespace boost
|
||||
|
||||
@@ -22,7 +22,7 @@ namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template<typename Iterator1, typename Iterator2>
|
||||
template<class Iterator1, class Iterator2>
|
||||
void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
|
||||
Iterator2 it2, Iterator2 last2,
|
||||
single_pass_traversal_tag,
|
||||
@@ -36,7 +36,7 @@ namespace boost
|
||||
}
|
||||
}
|
||||
|
||||
template<typename Iterator1, typename Iterator2>
|
||||
template<class Iterator1, class Iterator2>
|
||||
void swap_ranges_impl(Iterator1 it1, Iterator1 last1,
|
||||
Iterator2 it2, Iterator2 last2,
|
||||
random_access_traversal_tag,
|
||||
@@ -47,13 +47,13 @@ namespace boost
|
||||
std::swap_ranges(it1, last1, it2);
|
||||
}
|
||||
|
||||
template<typename Iterator1, typename Iterator2>
|
||||
template<class Iterator1, class Iterator2>
|
||||
void swap_ranges_impl(Iterator1 first1, Iterator1 last1,
|
||||
Iterator2 first2, Iterator2 last2)
|
||||
{
|
||||
swap_ranges_impl(first1, last1, first2, last2,
|
||||
typename iterator_traversal<Iterator1>::type(),
|
||||
typename iterator_traversal<Iterator2>::type());
|
||||
BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator1>::type(),
|
||||
BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator2>::type());
|
||||
}
|
||||
} // namespace range_detail
|
||||
|
||||
@@ -66,7 +66,7 @@ namespace boost
|
||||
///
|
||||
/// \pre SinglePassRange1 is a model of the SinglePassRangeConcept
|
||||
/// \pre SinglePassRange2 is a model of the SinglePassRangeConcept
|
||||
template< typename SinglePassRange1, typename SinglePassRange2 >
|
||||
template< class SinglePassRange1, class SinglePassRange2 >
|
||||
inline SinglePassRange2&
|
||||
swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2)
|
||||
{
|
||||
|
||||
@@ -19,55 +19,55 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
template<class InputIterator1, class InputIterator2, class Fn2>
|
||||
inline Fn2 for_each_impl(InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, InputIterator2 last2,
|
||||
Fn2 fn)
|
||||
{
|
||||
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
|
||||
{
|
||||
fn(*first1, *first2);
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
}
|
||||
namespace range_detail
|
||||
{
|
||||
template<class InputIterator1, class InputIterator2, class Fn2>
|
||||
inline Fn2 for_each_impl(InputIterator1 first1, InputIterator1 last1,
|
||||
InputIterator2 first2, InputIterator2 last2,
|
||||
Fn2 fn)
|
||||
{
|
||||
for (; first1 != last1 && first2 != last2; ++first1, ++first2)
|
||||
{
|
||||
fn(*first1, *first2);
|
||||
}
|
||||
return fn;
|
||||
}
|
||||
}
|
||||
|
||||
namespace range
|
||||
{
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
|
||||
namespace range
|
||||
{
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(const SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
|
||||
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
::boost::begin(rng1), ::boost::end(rng1),
|
||||
::boost::begin(rng2), ::boost::end(rng2), fn);
|
||||
}
|
||||
}
|
||||
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(const SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
|
||||
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
::boost::begin(rng1), ::boost::end(rng1),
|
||||
::boost::begin(rng2), ::boost::end(rng2), fn);
|
||||
}
|
||||
}
|
||||
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(SinglePassRange1& rng1, const SinglePassRange2& rng2, Fn2 fn)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> ));
|
||||
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
return ::boost::range_detail::for_each_impl(
|
||||
::boost::begin(rng1), ::boost::end(rng1),
|
||||
::boost::begin(rng2), ::boost::end(rng2), fn);
|
||||
}
|
||||
}
|
||||
|
||||
template<class SinglePassRange1, class SinglePassRange2, class Fn2>
|
||||
inline Fn2 for_each(SinglePassRange1& rng1, SinglePassRange2& rng2, Fn2 fn)
|
||||
@@ -79,8 +79,8 @@ namespace boost
|
||||
::boost::begin(rng1), ::boost::end(rng1),
|
||||
::boost::begin(rng2), ::boost::end(rng2), fn);
|
||||
}
|
||||
} // namespace range
|
||||
using range::for_each;
|
||||
} // namespace range
|
||||
using range::for_each;
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -25,41 +25,41 @@
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template<class Value>
|
||||
inline iterator_range<counting_iterator<Value> >
|
||||
counting_range(Value first, Value last)
|
||||
{
|
||||
typedef counting_iterator<Value> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return result_t(counting_iterator_t(first),
|
||||
counting_iterator_t(last));
|
||||
}
|
||||
template<class Value>
|
||||
inline iterator_range<counting_iterator<Value> >
|
||||
counting_range(Value first, Value last)
|
||||
{
|
||||
typedef counting_iterator<Value> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return result_t(counting_iterator_t(first),
|
||||
counting_iterator_t(last));
|
||||
}
|
||||
|
||||
template<class Range>
|
||||
inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> >
|
||||
counting_range(const Range& rng)
|
||||
{
|
||||
typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return boost::empty(rng)
|
||||
? result_t()
|
||||
: result_t(
|
||||
template<class Range>
|
||||
inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> >
|
||||
counting_range(const Range& rng)
|
||||
{
|
||||
typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<const Range>::type> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return boost::empty(rng)
|
||||
? result_t()
|
||||
: result_t(
|
||||
counting_iterator_t(*boost::begin(rng)),
|
||||
counting_iterator_t(*boost::prior(boost::end(rng))));
|
||||
}
|
||||
}
|
||||
|
||||
template<class Range>
|
||||
inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> >
|
||||
counting_range(Range& rng)
|
||||
{
|
||||
typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return boost::empty(rng)
|
||||
? result_t()
|
||||
: result_t(
|
||||
template<class Range>
|
||||
inline iterator_range<counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> >
|
||||
counting_range(Range& rng)
|
||||
{
|
||||
typedef counting_iterator<BOOST_DEDUCED_TYPENAME range_value<Range>::type> counting_iterator_t;
|
||||
typedef iterator_range<counting_iterator_t> result_t;
|
||||
return boost::empty(rng)
|
||||
? result_t()
|
||||
: result_t(
|
||||
counting_iterator_t(*boost::begin(rng)),
|
||||
counting_iterator_t(*boost::prior(boost::end(rng))));
|
||||
}
|
||||
}
|
||||
} // namespace boost
|
||||
|
||||
#if BOOST_MSVC >= 1400
|
||||
|
||||
@@ -15,8 +15,8 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
namespace range_detail
|
||||
{
|
||||
|
||||
template<class IteratorTraversalTag1, class IteratorTraversalTag2>
|
||||
struct demote_iterator_traversal_tag
|
||||
@@ -26,7 +26,7 @@ struct demote_iterator_traversal_tag
|
||||
#define BOOST_DEMOTE_TRAVERSAL_TAG( Tag1, Tag2, ResultTag ) \
|
||||
template<> struct demote_iterator_traversal_tag< Tag1 , Tag2 > \
|
||||
{ \
|
||||
typedef ResultTag type; \
|
||||
typedef ResultTag type; \
|
||||
};
|
||||
|
||||
BOOST_DEMOTE_TRAVERSAL_TAG( no_traversal_tag, no_traversal_tag, no_traversal_tag )
|
||||
@@ -73,7 +73,7 @@ BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, random_access_traversal
|
||||
|
||||
#undef BOOST_DEMOTE_TRAVERSAL_TAG
|
||||
|
||||
} // namespace range_detail
|
||||
} // namespace range_detail
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -16,19 +16,24 @@
|
||||
*/
|
||||
|
||||
#include <iterator>
|
||||
#include <istream>
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/range/range.hpp>
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template<class Type, class Elem, class Traits> inline
|
||||
range<std::istream_iterator<Type, Elem, Traits> >
|
||||
istream_range(std::basic_istream<Elem, Traits>& in)
|
||||
{
|
||||
return range<std::istream_iterator<Type, Elem, Traits> >(
|
||||
std::istream_iterator<Type>(in),
|
||||
std::istream_iterator<Type>());
|
||||
}
|
||||
namespace range
|
||||
{
|
||||
template<class Type, class Elem, class Traits> inline
|
||||
iterator_range<std::istream_iterator<Type, Elem, Traits> >
|
||||
istream_range(std::basic_istream<Elem, Traits>& in)
|
||||
{
|
||||
return iterator_range<std::istream_iterator<Type, Elem, Traits> >(
|
||||
std::istream_iterator<Type>(in),
|
||||
std::istream_iterator<Type>());
|
||||
}
|
||||
} // namespace range
|
||||
using range::istream_range;
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -21,46 +21,46 @@ namespace boost
|
||||
|
||||
template<class SinglePassRange1, class SinglePassRange2>
|
||||
iterator_range<range_detail::join_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME add_const<
|
||||
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type>
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME add_const<
|
||||
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type>
|
||||
>
|
||||
join(const SinglePassRange1& r1, const SinglePassRange2& r2)
|
||||
{
|
||||
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,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME add_const<
|
||||
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type> iterator_t;
|
||||
typedef range_detail::join_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME add_const<
|
||||
BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange1>::type>::type> iterator_t;
|
||||
|
||||
return iterator_range<iterator_t>(
|
||||
iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
|
||||
iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
|
||||
return iterator_range<iterator_t>(
|
||||
iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
|
||||
iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
|
||||
}
|
||||
|
||||
template<class SinglePassRange1, class SinglePassRange2>
|
||||
iterator_range<range_detail::join_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type>
|
||||
>
|
||||
join(SinglePassRange1& r1, SinglePassRange2& r2)
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> ));
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> ));
|
||||
|
||||
typedef range_detail::join_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
|
||||
typedef range_detail::join_iterator<
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type,
|
||||
BOOST_DEDUCED_TYPENAME range_value<SinglePassRange1>::type> iterator_t;
|
||||
|
||||
return iterator_range<iterator_t>(
|
||||
iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
|
||||
iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
|
||||
return iterator_range<iterator_t>(
|
||||
iterator_t(r1, r2, range_detail::join_iterator_begin_tag()),
|
||||
iterator_t(r1, r2, range_detail::join_iterator_end_tag()));
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
|
||||
@@ -20,7 +20,7 @@
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if defined(_MSC_VER) && _MSC_VER >= 1000
|
||||
#pragma once
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#ifndef BOOST_RANGE_NUMERIC_HPP
|
||||
@@ -36,82 +36,82 @@
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template< class SinglePassRange, class Value >
|
||||
inline Value accumulate( const SinglePassRange& rng, Value init )
|
||||
{
|
||||
template< class SinglePassRange, class Value >
|
||||
inline Value accumulate( const SinglePassRange& rng, Value init )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::accumulate( boost::begin(rng), boost::end(rng), init );
|
||||
}
|
||||
return std::accumulate( boost::begin(rng), boost::end(rng), init );
|
||||
}
|
||||
|
||||
template< class SinglePassRange, class Value, class BinaryOperation >
|
||||
inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
|
||||
{
|
||||
template< class SinglePassRange, class Value, class BinaryOperation >
|
||||
inline Value accumulate( const SinglePassRange& rng, Value init, BinaryOperation op )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
|
||||
}
|
||||
return std::accumulate( boost::begin(rng), boost::end(rng), init, op );
|
||||
}
|
||||
|
||||
|
||||
template< class SinglePassRange1, class SinglePassRange2, class Value >
|
||||
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
|
||||
{
|
||||
template< class SinglePassRange1, class SinglePassRange2, class Value >
|
||||
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2, Value init )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
|
||||
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
|
||||
return std::inner_product( boost::begin(rng1), boost::end(rng1),
|
||||
return std::inner_product( boost::begin(rng1), boost::end(rng1),
|
||||
boost::begin(rng2), init );
|
||||
}
|
||||
}
|
||||
|
||||
template< class SinglePassRange1,
|
||||
template< class SinglePassRange1,
|
||||
class SinglePassRange2,
|
||||
class Value,
|
||||
class BinaryOperation1, class BinaryOperation2 >
|
||||
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
|
||||
class BinaryOperation1, class BinaryOperation2 >
|
||||
inline Value inner_product( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
|
||||
Value init,
|
||||
BinaryOperation1 op1, BinaryOperation2 op2 )
|
||||
{
|
||||
BinaryOperation1 op1, BinaryOperation2 op2 )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange1> >();
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange2> >();
|
||||
BOOST_ASSERT( boost::distance(rng2) >= boost::distance(rng1) );
|
||||
|
||||
return std::inner_product( boost::begin(rng1), boost::end(rng1),
|
||||
return std::inner_product( boost::begin(rng1), boost::end(rng1),
|
||||
boost::begin(rng2), init, op1, op2 );
|
||||
}
|
||||
}
|
||||
|
||||
template< class SinglePassRange, class OutputIterator >
|
||||
inline OutputIterator partial_sum ( const SinglePassRange& rng,
|
||||
OutputIterator result )
|
||||
{
|
||||
template< class SinglePassRange, class OutputIterator >
|
||||
inline OutputIterator partial_sum ( const SinglePassRange& rng,
|
||||
OutputIterator result )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::partial_sum( boost::begin(rng), boost::end(rng), result );
|
||||
}
|
||||
return std::partial_sum( boost::begin(rng), boost::end(rng), result );
|
||||
}
|
||||
|
||||
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
|
||||
inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
|
||||
BinaryOperation op )
|
||||
{
|
||||
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
|
||||
inline OutputIterator partial_sum ( const SinglePassRange& rng, OutputIterator result,
|
||||
BinaryOperation op )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
|
||||
}
|
||||
return std::partial_sum( boost::begin(rng), boost::end(rng), result, op );
|
||||
}
|
||||
|
||||
template< class SinglePassRange, class OutputIterator >
|
||||
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
|
||||
OutputIterator result )
|
||||
{
|
||||
template< class SinglePassRange, class OutputIterator >
|
||||
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
|
||||
OutputIterator result )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
|
||||
result );
|
||||
}
|
||||
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
|
||||
result );
|
||||
}
|
||||
|
||||
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
|
||||
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
|
||||
OutputIterator result,
|
||||
BinaryOperation op )
|
||||
{
|
||||
template< class SinglePassRange, class OutputIterator, class BinaryOperation >
|
||||
inline OutputIterator adjacent_difference ( const SinglePassRange& rng,
|
||||
OutputIterator result,
|
||||
BinaryOperation op )
|
||||
{
|
||||
boost::function_requires< SinglePassRangeConcept<SinglePassRange> >();
|
||||
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
|
||||
result, op );
|
||||
}
|
||||
|
||||
return std::adjacent_difference( boost::begin(rng), boost::end(rng),
|
||||
result, op );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -68,7 +68,7 @@ namespace boost
|
||||
|
||||
template< class T >
|
||||
struct range_size<const T >
|
||||
: detail::range_size<T>
|
||||
: detail::range_size<T>
|
||||
{ };
|
||||
|
||||
} // namespace boost
|
||||
|
||||
@@ -1,73 +0,0 @@
|
||||
#ifndef BOOST_RANGE_UNBOUNDED_RANGE_HPP
|
||||
#define BOOST_RANGE_UNBOUNDED_RANGE_HPP
|
||||
|
||||
#include <boost/range/iterator_range.hpp>
|
||||
#include <boost/config.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
template< class Iter >
|
||||
struct unbounded_iterator_range : iterator_range<Iter>
|
||||
{
|
||||
explicit unbounded_iterator_range( Iter r )
|
||||
: iterator_range<Iter>( r, r )
|
||||
{
|
||||
//
|
||||
// Remark: by storing the same iterator
|
||||
// twice, we can still allow
|
||||
// comparison to execute without leading to
|
||||
// operations on singular iterators
|
||||
//
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
bool empty() const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
//
|
||||
// Hide members that are illegal to use.
|
||||
//
|
||||
/*
|
||||
void end() const;
|
||||
void size() const;
|
||||
void empty() const;
|
||||
void equal() const;
|
||||
operator bool() const;
|
||||
bool operator==( unbounded_iterator_range );
|
||||
bool operator!=( unbounded_iterator_range );
|
||||
template< class S >
|
||||
void operator[]( S s ) const;
|
||||
template< class D >
|
||||
void advance_end( D d ) const;
|
||||
void back() const;
|
||||
*/
|
||||
};
|
||||
|
||||
template< class Iter >
|
||||
inline unbounded_iterator_range<Iter> unbounded_range( Iter r )
|
||||
{
|
||||
return unbounded_iterator_range<Iter>(r);
|
||||
}
|
||||
|
||||
namespace detail
|
||||
{
|
||||
char is_unbounded_range( ... );
|
||||
template< class Iter >
|
||||
long is_unbounded_range( const unbounded_iterator_range<Iter>* );
|
||||
}
|
||||
|
||||
template< class T >
|
||||
struct is_unbounded_range
|
||||
{
|
||||
private:
|
||||
static T* ptr_;
|
||||
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT( bool,
|
||||
value = sizeof(long) == sizeof(detail::is_unbounded_range(ptr_) ) );
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user