zip.h

Go to the documentation of this file.

 
#pragma once
 
#include "./range.h"
#include "./types.h"
#include "./view.h"
 
#include <tuple>
 
namespace emlabcpp
{
template < typename... >
class zip_iterator;
}
 
template < typename... Iterators >
struct std::iterator_traits< emlabcpp::zip_iterator< Iterators... > >
{
        using value_type = std::tuple< typename std::iterator_traits< Iterators >::reference... >;
        using difference_type   = std::ptrdiff_t;
        using pointer           = void;
        using reference         = value_type;
        using iterator_category = std::bidirectional_iterator_tag;
};
 
namespace emlabcpp
{
 
template < typename... Iterators >
class zip_iterator
{
        std::tuple< Iterators... > iters_;
 
public:
        constexpr zip_iterator( Iterators... iters )
          : iters_( std::move( iters )... )
        {
        }
 
        constexpr zip_iterator operator++()
        {
                std::apply(
                    []( auto&&... it ) {  //
                            ( ++it, ... );
                    },
                    iters_ );
 
                return *this;
        }
 
        constexpr zip_iterator operator--()
        {
                std::apply(
                    []( auto&&... it ) {  //
                            ( ++it, ... );
                    },
                    iters_ );
 
                return *this;
        }
 
        constexpr zip_iterator& operator+=( std::ptrdiff_t m )
        {
                for_each( iters_, [&]( auto& iter ) {
                        iter += m;
                } );
                return *this;
        }
 
        constexpr std::ptrdiff_t operator-( zip_iterator< Iterators... > const& other ) const
        {
                return std::get< 0 >( iters_ ) - std::get< 0 >( other.iters_ );
        }
 
        constexpr auto operator*()
        {
                return std::apply(
                    []( auto&&... it ) {  //
                            return std::forward_as_tuple( ( *it )... );
                    },
                    iters_ );
        }
 
        constexpr bool operator==( zip_iterator< Iterators... > const& other ) const
        {
                return equals( other, std::index_sequence_for< Iterators... >{} );
        }
 
private:
        template < typename std::size_t... Idx >
        [[nodiscard]] constexpr bool
        equals( zip_iterator< Iterators... > const& other, std::index_sequence< Idx... > ) const
        {
                return ( ( std::get< Idx >( iters_ ) == std::get< Idx >( other.iters_ ) ) || ... );
        }
};
 
template < typename... Iterators >
constexpr zip_iterator< Iterators... >
operator+( zip_iterator< Iterators... > lh, std::ptrdiff_t m )
{
        lh += m;
        return lh;
}
 
template < typename... Iterators >
constexpr bool
operator!=( zip_iterator< Iterators... > const& lh, zip_iterator< Iterators... > const& rh )
{
        return !( lh == rh );
}
 
//
template < range_container... Ts >
auto zip( Ts&&... cont )
{
        return view( zip_iterator( std::begin( cont )... ), zip_iterator( std::end( cont )... ) );
}
 
template < typename TuplesTuple, std::size_t... ItemIndexes, std::size_t... TupleIndexes >
auto tuple_zip_impl(
    TuplesTuple&& tpls,
    std::index_sequence< ItemIndexes... >,
    std::index_sequence< TupleIndexes... > )
{
        auto f = [&]< typename Index >( Index ) {
                return std::make_tuple(
                    std::get< Index::value >( std::get< TupleIndexes >( tpls ) )... );
        };
 
        return std::make_tuple( f( std::integral_constant< std::size_t, ItemIndexes >{} )... );
}
 
template < gettable_container Tuple, gettable_container... Tuples >
auto zip( Tuple&& frst, Tuples&&... tpls )
{
        static_assert(
            ( ( static_size_v< Tuple > == static_size_v< Tuples > ) && ... ),
            "All tuples has to be of same size in zip" );
        return tuple_zip_impl(
            std::make_tuple( frst, tpls... ),
            std::make_index_sequence< static_size_v< Tuple > >{},
            std::make_index_sequence< sizeof...( Tuples ) + 1 >{} );
}
 
}  // namespace emlabcpp