You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
304 lines
11 KiB
304 lines
11 KiB
// Copyright Neil Groves 2010. Use, modification and |
|
// distribution is subject to the Boost Software License, Version |
|
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
|
// http://www.boost.org/LICENSE_1_0.txt) |
|
// |
|
// |
|
// For more information, see http://www.boost.org/libs/range/ |
|
// |
|
#ifndef BOOST_RANGE_COMBINE_HPP |
|
#define BOOST_RANGE_COMBINE_HPP |
|
|
|
#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> |
|
#include <boost/mpl/eval_if.hpp> |
|
#include <boost/mpl/int.hpp> |
|
#include <boost/mpl/plus.hpp> |
|
#include <boost/mpl/arithmetic.hpp> |
|
#include <boost/config.hpp> |
|
|
|
namespace boost |
|
{ |
|
namespace range_detail |
|
{ |
|
struct void_ { typedef void_ type; }; |
|
} |
|
|
|
template<> struct range_iterator< ::boost::range_detail::void_ > |
|
{ |
|
typedef ::boost::tuples::null_type type; |
|
}; |
|
|
|
namespace range_detail |
|
{ |
|
inline ::boost::tuples::null_type range_begin( ::boost::range_detail::void_& ) |
|
{ return ::boost::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 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 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 |
|
< |
|
class R1, |
|
class R2, |
|
class R3, |
|
class R4, |
|
class R5, |
|
class R6 |
|
> |
|
struct generate_tuple |
|
{ |
|
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 ::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 ::boost::tuples::make_tuple( ::boost::end(r1), |
|
::boost::end(r2), |
|
::boost::end(r3), |
|
::boost::end(r4), |
|
::boost::end(r5), |
|
::boost::end(r6) ); |
|
} |
|
}; |
|
|
|
template |
|
< |
|
class R1, |
|
class R2 = void_, |
|
class R3 = void_, |
|
class R4 = void_, |
|
class R5 = void_, |
|
class R6 = void_ |
|
> |
|
struct zip_rng |
|
: iterator_range< |
|
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_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_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)); |
|
} |
|
|
|
template< class Zip, class Rng > |
|
zip_rng( Zip& z, Rng& 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 : ::boost::tuples::length<tuple_t> |
|
{ }; |
|
|
|
template< unsigned N > |
|
struct get |
|
{ |
|
template< class Z, class 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 BOOST_DEDUCED_TYPENAME ::boost::tuples::element<N,tuple_t>::type end( Z& z, R& r ) |
|
{ |
|
return get<N>( z.end().get_iterator_tuple() ); |
|
} |
|
}; |
|
|
|
}; |
|
|
|
template< class Rng1, class Rng2 > |
|
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< |
|
::boost::tuples::tuple< |
|
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng1>::type, |
|
BOOST_DEDUCED_TYPENAME ::boost::range_iterator<Rng2>::type |
|
> |
|
> zip_iter_t; |
|
typedef iterator_range<zip_iter_t> base_t; |
|
|
|
public: |
|
zip_range( Rng1& r1, Rng2& 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)); |
|
} |
|
}; |
|
|
|
template< class Rng1, class Rng2, class Rng3 > |
|
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< |
|
::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_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(::boost::distance(r1) <= ::boost::distance(r2)); |
|
BOOST_ASSERT(::boost::distance(r1) <= ::boost::distance(r3)); |
|
} |
|
}; |
|
|
|
|
|
struct combine_tag {}; |
|
|
|
template< class Rng > |
|
inline zip_rng<Rng> |
|
operator&( combine_tag, Rng& r ) |
|
{ |
|
return zip_rng<Rng>(r); |
|
} |
|
|
|
template< class Rng > |
|
inline iterator_range<const Rng> |
|
operator&( combine_tag, const Rng& r ) |
|
{ |
|
return iterator_range<const Rng>(r); |
|
} |
|
|
|
template |
|
< |
|
class R1, |
|
class R2, |
|
class R3, |
|
class R4, |
|
class R5, |
|
class Rng |
|
> |
|
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 ); |
|
} |
|
|
|
} // namespace range_detail |
|
|
|
template< class Rng1, class Rng2 > |
|
inline ::boost::range_detail::zip_range<Rng1, Rng2> combine( Rng1& r1, Rng2& r2 ) |
|
{ |
|
return ::boost::range_detail::zip_range<Rng1, Rng2>(r1, r2); |
|
} |
|
|
|
template< class Rng1, class Rng2 > |
|
inline ::boost::range_detail::zip_range<const Rng1, Rng2> combine( const Rng1& r1, Rng2& r2 ) |
|
{ |
|
return ::boost::range_detail::zip_range<const Rng1, Rng2>(r1, r2); |
|
} |
|
|
|
template< class Rng1, class Rng2 > |
|
inline ::boost::range_detail::zip_range<Rng1, const Rng2> combine( Rng1& r1, const Rng2& r2 ) |
|
{ |
|
return ::boost::range_detail::zip_range<Rng1, const Rng2>(r1, r2); |
|
} |
|
|
|
template< class Rng1, class Rng2 > |
|
inline ::boost::range_detail::zip_range<const Rng1, const Rng2> combine( const Rng1& r1, const Rng2& r2 ) |
|
{ |
|
return ::boost::range_detail::zip_range<const Rng1, const Rng2>(r1, r2); |
|
} |
|
|
|
} // namespace boost |
|
|
|
#endif
|
|
|