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

Boost.Range merge of fixes from the trunk.

Browse Source 
[SVN r61146]
This commit is contained in:
Neil Groves
2010-04-08 19:34:17 +00:00
parent 29b2053f5c
commit eea32403ef
143 changed files with 903 additions and 951 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/boost/range/adaptor/adjacent_filtered.hpp
+91 -107
View File
@@ -30,94 +30,58 @@ namespace boost
namespace range_detail
{
template< class Iter, class R >
template< class Iter, class Pred, bool default_pass >
class skip_iterator
: public boost::iterator_adaptor< skip_iterator<Iter,R>, Iter >
: public boost::iterator_adaptor<
skip_iterator<Iter,Pred,default_pass>,
Iter,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
boost::forward_traversal_tag,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::reference,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
>
, private Pred
{
private:
typedef boost::iterator_adaptor< skip_iterator<Iter,R>, Iter >
base_t;
R* range;
typedef boost::iterator_adaptor<
skip_iterator<Iter,Pred,default_pass>,
Iter,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::value_type,
boost::forward_traversal_tag,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::reference,
BOOST_DEDUCED_TYPENAME std::iterator_traits<Iter>::difference_type
> base_t;
public:
typedef Iter wrapped_iter_t;
typedef Pred pred_t;
typedef Iter iter_t;
//
// The iterators are bound to the lifetime of the
// range and may not exist on their own. Hence it makes no
// sense to e.g. wrap them in reverse_iterators
// (that can OTOH be done in advance).
//
typedef std::input_iterator_tag iterator_category;
skip_iterator() : m_last() {}
explicit skip_iterator( R* r, Iter i )
: base_t(i), range(r) {}
template< class OtherIter, class R2>
skip_iterator( const skip_iterator<OtherIter,R2>& other )
: base_t( other.base() ) {}
R* get_range() const { return range; }
private:
friend class boost::iterator_core_access;
void increment()
{
BOOST_ASSERT( range != 0 );
range->increment_impl( this->base_reference() );
}
//
// Not needed ... just apply a reverse_iterator
//
void decrement()
skip_iterator(iter_t it, iter_t last, const Pred& pred)
: base_t(it)
, pred_t(pred)
, m_last(last)
{
BOOST_ASSERT( false && "you can't decrement an adjacent_filter_iterator" );
move_to_next_valid();
}
template< class D >
void advance( D n )
{
BOOST_ASSERT( false );
}
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 P, class R >
struct adjacent_filter_range
: iterator_range< skip_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
adjacent_filter_range<P,R>
>
>
{
private:
typedef skip_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
adjacent_filter_range<P,R>
>
skip_iter;
typedef iterator_range<skip_iter>
base_range;
typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
P m_bi_pred;
// Get the first element in the half-open range that
// passes the filter predicate.
// The adjacent_filter_range must only contain values that pass
// through the filter.
static raw_iterator to_valid(raw_iterator it, raw_iterator last, const P& bi_pred, bool default_pass)
void move_to_next_valid()
{
if (it != last)
iter_t& it = this->base_reference();
pred_t& bi_pred = *this;
if (it != m_last)
{
if (default_pass)
{
raw_iterator nxt = ::boost::next(it);
while (nxt != last && !bi_pred(*it, *nxt))
iter_t nxt = ::boost::next(it);
while (nxt != m_last && !bi_pred(*it, *nxt))
{
++it;
++nxt;
@@ -125,41 +89,61 @@ namespace boost
}
else
{
raw_iterator nxt = ::boost::next(it);
for(; nxt != last; ++it, ++nxt)
iter_t nxt = ::boost::next(it);
for(; nxt != m_last; ++it, ++nxt)
{
if (bi_pred(*it, *nxt))
{
break;
}
}
if (nxt == last)
if (nxt == m_last)
{
it = last;
it = m_last;
}
}
}
return it;
}
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
>
>
{
private:
typedef skip_iterator<
BOOST_DEDUCED_TYPENAME range_iterator<R>::type,
P,
default_pass
>
skip_iter;
typedef iterator_range<skip_iter>
base_range;
typedef BOOST_DEDUCED_TYPENAME range_iterator<R>::type raw_iterator;
public:
adjacent_filter_range( const P& p, R& r, bool default_pass )
: base_range( skip_iter( this, to_valid(boost::begin(r), boost::end(r), p, default_pass)),
skip_iter( this, boost::end(r) ) ),
m_bi_pred( p ),
m_default_pass(default_pass)
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) )
{
}
void increment_impl( raw_iterator& current )
{
BOOST_ASSERT( current != this->end().base() );
current = to_valid(::boost::next(current), this->end().base(), m_bi_pred, m_default_pass);
}
private:
bool m_default_pass;
};
template< class T >
@@ -177,37 +161,37 @@ namespace boost
};
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng>
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
operator|( ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate, ForwardRng>( f.val, r, true );
return adjacent_filter_range<BinPredicate, ForwardRng, true>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, const ForwardRng>
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
operator|( const ForwardRng& r,
const adjacent_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate,
const ForwardRng>( f.val, r, true );
const ForwardRng, true>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng>
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
operator|( ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate, ForwardRng>( f.val, r, false );
return adjacent_filter_range<BinPredicate, ForwardRng, false>( f.val, r );
}
template< class ForwardRng, class BinPredicate >
inline adjacent_filter_range<BinPredicate, ForwardRng>
inline adjacent_filter_range<BinPredicate, ForwardRng, false>
operator|( const ForwardRng& r,
const adjacent_excl_holder<BinPredicate>& f )
{
return adjacent_filter_range<BinPredicate,
const ForwardRng>( f.val, r, false );
const ForwardRng, false>( f.val, r );
}
} // 'range_detail'
@@ -231,17 +215,17 @@ namespace boost
}
template<class ForwardRng, class BinPredicate>
inline adjacent_filter_range<BinPredicate, ForwardRng>
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred, bool default_pass = true)
inline adjacent_filter_range<BinPredicate, ForwardRng, true>
adjacent_filter(ForwardRng& rng, BinPredicate filter_pred)
{
return adjacent_filter_range<BinPredicate, ForwardRng>(filter_pred, rng, default_pass);
return adjacent_filter_range<BinPredicate, ForwardRng, true>(filter_pred, rng);
}
template<class ForwardRng, class BinPredicate>
inline adjacent_filter_range<BinPredicate, const ForwardRng>
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred, bool default_pass = true)
inline adjacent_filter_range<BinPredicate, const ForwardRng, true>
adjacent_filter(const ForwardRng& rng, BinPredicate filter_pred)
{
return adjacent_filter_range<BinPredicate, const ForwardRng>(filter_pred, rng, default_pass);
return adjacent_filter_range<BinPredicate, const ForwardRng, true>(filter_pred, rng);
}
} // 'adaptors'
include/boost/range/adaptor/uniqued.hpp
+21 -21
View File
@@ -15,68 +15,68 @@
namespace boost
{
namespace range_detail
{
struct unique_forwarder { };
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 ForwardRng>
class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng>
class unique_range : public adjacent_filter_range<unique_not_equal_to, ForwardRng, true>
{
typedef adjacent_filter_range<unique_not_equal_to, ForwardRng> base;
typedef adjacent_filter_range<unique_not_equal_to, ForwardRng, true> base;
public:
explicit unique_range(ForwardRng& rng)
: base(unique_not_equal_to(), rng, true)
: base(unique_not_equal_to(), rng)
{
}
};
template< class ForwardRng >
inline unique_range<ForwardRng>
operator|( ForwardRng& r,
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,
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 =
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)
@@ -84,7 +84,7 @@ namespace boost
return unique_range<const ForwardRange>(rng);
}
} // 'adaptors'
}
#endif
include/boost/range/combine.hpp
+129 -143
View File
@@ -3,6 +3,7 @@
#include <boost/iterator/zip_iterator.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/range/iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/type_traits/is_void.hpp>
#include <boost/type_traits/is_same.hpp>
@@ -14,40 +15,48 @@
namespace boost
{
namespace detail
namespace range_detail
{
struct void_ { typedef void_ type; };
}
template<> struct range_iterator<detail::void_>
template<> struct range_iterator< ::boost::range_detail::void_ >
{
typedef tuples::null_type type;
typedef ::boost::tuples::null_type type;
};
namespace detail
namespace range_detail
{
inline tuples::null_type range_begin( void_& )
{ return tuples::null_type(); }
inline ::boost::tuples::null_type range_begin( ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline tuples::null_type range_end( void_& )
{ return tuples::null_type(); }
inline ::boost::tuples::null_type range_begin( const ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline ::boost::tuples::null_type range_end( ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
inline ::boost::tuples::null_type range_end( const ::boost::range_detail::void_& )
{ return ::boost::tuples::null_type(); }
template< class T >
struct tuple_iter
{
typedef typename mpl::eval_if_c< is_same<T,void_>::value,
mpl::identity<tuples::null_type>,
range_iterator<T> >::type
type;
typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
::boost::is_same<T, ::boost::range_detail::void_ >::value,
::boost::mpl::identity< ::boost::tuples::null_type >,
::boost::range_iterator<T>
>::type type;
};
template< class Rng1, class Rng2 >
struct tuple_range
{
typedef typename mpl::eval_if_c< is_same<Rng1,void_>::value,
void_,
mpl::identity<Rng1> >::type
type;
typedef BOOST_DEDUCED_TYPENAME ::boost::mpl::eval_if_c<
::boost::is_same<Rng1, ::boost::range_detail::void_ >::value,
::boost::range_detail::void_,
::boost::mpl::identity<Rng1>
>::type type;
};
template
@@ -57,36 +66,37 @@ namespace boost
class R3,
class R4,
class R5,
class R6
class R6
>
struct generate_tuple
{
typedef boost::tuple< typename tuple_iter<R1>::type,
typename tuple_iter<R2>::type,
typename tuple_iter<R3>::type,
typename tuple_iter<R4>::type,
typename tuple_iter<R5>::type,
typename tuple_iter<R6>::type >
type;
typedef ::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME tuple_iter<R1>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R2>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R3>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R4>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R5>::type,
BOOST_DEDUCED_TYPENAME tuple_iter<R6>::type
> type;
static type begin( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
{
return make_tuple( boost::begin(r1),
boost::begin(r2),
boost::begin(r3),
boost::begin(r4),
boost::begin(r5),
boost::begin(r6) );
return ::boost::tuples::make_tuple( ::boost::begin(r1),
::boost::begin(r2),
::boost::begin(r3),
::boost::begin(r4),
::boost::begin(r5),
::boost::begin(r6) );
}
static type end( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
{
return make_tuple( boost::end(r1),
boost::end(r2),
boost::end(r3),
boost::end(r4),
boost::end(r5),
boost::end(r6) );
return ::boost::tuples::make_tuple( ::boost::end(r1),
::boost::end(r2),
::boost::end(r3),
::boost::end(r4),
::boost::end(r5),
::boost::end(r6) );
}
};
@@ -101,54 +111,52 @@ namespace boost
>
struct zip_rng
: iterator_range<
zip_iterator< typename generate_tuple<R1,R2,R3,R4,R5,R6>::type >
>
zip_iterator<
BOOST_DEDUCED_TYPENAME generate_tuple<R1,R2,R3,R4,R5,R6>::type
>
>
{
private:
typedef generate_tuple<R1,R2,R3,R4,R5,R6>
generator;
typedef typename generator::type
tuple;
typedef zip_iterator<tuple>
zip_iter;
typedef iterator_range<zip_iter>
base;
typedef generate_tuple<R1,R2,R3,R4,R5,R6> generator_t;
typedef BOOST_DEDUCED_TYPENAME generator_t::type tuple_t;
typedef zip_iterator<tuple_t> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_rng( R1& r1, R2& r2, R3& r3, R4& r4, R5& r5, R6& r6 )
: base( zip_iter( generator::begin(r1,r2,r3,r4,r5,r6) ),
zip_iter( generator::end(r1,r2,r3,r4,r5,r6) ) )
: base_t( zip_iter_t( generator_t::begin(r1,r2,r3,r4,r5,r6) ),
zip_iter_t( generator_t::end(r1,r2,r3,r4,r5,r6) ) )
{
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r2));
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r3));
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r4));
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r5));
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r6));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r4));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r5));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r6));
}
template< class Zip, class Rng >
zip_rng( Zip& z, Rng& r )
: base( zip_iter( generator::begin( z, r ) ),
zip_iter( generator::end( z, r ) ) )
: base_t( zip_iter_t( generator_t::begin( z, r ) ),
zip_iter_t( generator_t::end( z, r ) ) )
{
// @todo: tuple::begin( should be overloaded for this situation
}
struct tuple_length : tuples::length<tuple>
struct tuple_length : ::boost::tuples::length<tuple_t>
{ };
template< unsigned N >
struct get
{
template< class Z, class R >
static typename tuples::element<N,tuple>::type begin( Z& z, R& )
static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type begin( Z& z, R& )
{
return get<N>( z.begin().get_iterator_tuple() );
}
template< class Z, class R >
static typename tuples::element<N,tuple>::type end( Z& z, R& r )
static BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type end( Z& z, R& r )
{
return get<N>( z.end().get_iterator_tuple() );
}
@@ -157,64 +165,70 @@ namespace boost
};
template< class Rng1, class Rng2 >
struct zip_range
: iterator_range<
zip_iterator<
tuple< typename range_iterator<Rng1>::type,
typename range_iterator<Rng2>::type >
> >
struct zip_range
: iterator_range<
zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
>
>
>
{
private:
typedef zip_iterator<
tuple< typename range_iterator<Rng1>::type,
typename range_iterator<Rng2>::type >
typedef zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type
>
zip_iter;
typedef iterator_range<zip_iter>
base;
> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_range( Rng1& r1, Rng2& r2 )
: base( zip_iter( make_tuple(boost::begin(r1),
boost::begin(r2)) ),
zip_iter( make_tuple(boost::end(r1),
boost::end(r2)) ) )
: base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
::boost::begin(r2)) ),
zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
::boost::end(r2)) ) )
{
BOOST_ASSERT(boost::distance(r1) <= boost::distance(r2));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
}
};
template< class Rng1, class Rng2, class Rng3 >
struct zip_range3
: iterator_range<
zip_iterator<
tuple< typename range_iterator<Rng1>::type,
typename range_iterator<Rng2>::type,
typename range_iterator<Rng3>::type >
> >
struct zip_range3
: iterator_range<
zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
>
>
>
{
private:
typedef zip_iterator<
tuple< typename range_iterator<Rng1>::type,
typename range_iterator<Rng2>::type,
typename range_iterator<Rng3>::type >
>
zip_iter;
typedef iterator_range<zip_iter>
base;
typedef zip_iterator<
::boost::tuples::tuple<
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type,
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng3>::type
>
> zip_iter_t;
typedef iterator_range<zip_iter_t> base_t;
public:
zip_range3( Rng1& r1, Rng2& r2, Rng3& r3 )
: base( zip_iter( make_tuple(boost::begin(r1),
boost::begin(r2),
boost::begin(r3)) ),
zip_iter( make_tuple(boost::end(r1),
boost::end(r2),
boost::end(r3)) )
)
: base_t( zip_iter_t( ::boost::tuples::make_tuple(::boost::begin(r1),
::boost::begin(r2),
::boost::begin(r3)) ),
zip_iter_t( ::boost::tuples::make_tuple(::boost::end(r1),
::boost::end(r2),
::boost::end(r3)) )
)
{
BOOST_ASSERT(distance(r1) <= distance(r2));
BOOST_ASSERT(distance(r1) <= distance(r3));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r2));
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3));
}
};
@@ -222,89 +236,61 @@ namespace boost
struct combine_tag {};
template< class Rng >
inline zip_rng<Rng>
inline zip_rng<Rng>
operator&( combine_tag, Rng& r )
{
return zip_rng<Rng>(r);
}
template< class Rng >
inline iterator_range<const Rng>
inline iterator_range<const Rng>
operator&( combine_tag, const Rng& r )
{
return iterator_range<const Rng>(r);
}
template
<
class R1,
<
class R1,
class R2,
class R3,
class R4,
class R5,
class Rng
>
inline typename zip_rng<R1,R2,R3,R4,R5>::next
operator&( const zip_rng<R1,R2,R3,R4,R5>& zip,
inline BOOST_DEDUCED_TYPENAME zip_rng<R1,R2,R3,R4,R5>::next
operator&( const zip_rng<R1,R2,R3,R4,R5>& zip,
Rng& r )
{
return zip_rng<R1,R2,R3,R4,R5>::next( zip, r );
}
//
// This one should be able to be made generic
//
// template
// <
// class R1,
// class R2 = void,
// class R3 = void,
// class R4 = void,
// class R5 = void,
// class R6 = void
// >
// inline zip_range<R1,R2,R3,R4,R4,R5,R6>::type
// x
//
//
/*
template< class Rng1, class Rng2, class Rng3 >
inline zip_range3<Rng1,Rng2,Rng3>
operator&( const zip_range<Rng1,Rng2>& r1, const Rng3& r3 )
{
return zip_range3<Rn1,Rng2,Rng3>(
}*/
} // namespace 'detail'
} // namespace range_detail
template< class Rng1, class Rng2 >
inline detail::zip_range<Rng1,Rng2> combine( Rng1& r1, Rng2& r2 )
inline ::boost::range_detail::zip_range<Rng1, Rng2> combine( Rng1& r1, Rng2& r2 )
{
return detail::zip_range<Rng1,Rng2>(r1,r2);
return ::boost::range_detail::zip_range<Rng1, Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline detail::zip_range<const Rng1,Rng2> combine( const Rng1& r1, Rng2& r2 )
inline ::boost::range_detail::zip_range<const Rng1, Rng2> combine( const Rng1& r1, Rng2& r2 )
{
return detail::zip_range<const Rng1,Rng2>(r1,r2);
return ::boost::range_detail::zip_range<const Rng1, Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline detail::zip_range<Rng1,const Rng2> combine( Rng1& r1, const Rng2& r2 )
inline ::boost::range_detail::zip_range<Rng1, const Rng2> combine( Rng1& r1, const Rng2& r2 )
{
return detail::zip_range<Rng1,Rng2>(r1,r2);
return ::boost::range_detail::zip_range<Rng1, const Rng2>(r1, r2);
}
template< class Rng1, class Rng2 >
inline detail::zip_range<const Rng1,const Rng2> combine( const Rng1& r1, const Rng2& r2 )
inline ::boost::range_detail::zip_range<const Rng1, const Rng2> combine( const Rng1& r1, const Rng2& r2 )
{
return detail::zip_range<const Rng1,const Rng2>(r1,r2);
return ::boost::range_detail::zip_range<const Rng1, const Rng2>(r1, r2);
}
//
// @todo: find a solution that scales better
// instead of adding 6 overloads!
//
}
} // namespace boost
#endif
include/boost/range/size_type.hpp
Executable → Regular
+2 -1
View File
@@ -67,7 +67,8 @@ namespace boost
{ };
template< class T >
struct range_size<const T > : range_size<T>
struct range_size<const T >
: detail::range_size<T>
{ };
} // namespace boost