zip.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_ZIP_HPP
#define SIG_UTIL_ZIP_HPP

#include "high_order.hpp"


namespace sig
{

template <class... Cs
#if (SIG_MSVC_ENV && !(SIG_MSVC_VER <= 140)) || (SIG_GCC_ENV) || (SIG_CLANG_ENV)
    , typename std::enable_if< And(impl::container_traits<typename impl::remove_const_reference<Cs>::type>::exist...) >::type*& = enabler
#endif
    >
auto zip(Cs&&... lists)
{
    return variadicZipWith(
#if SIG_ENABLE_MOVEITERATOR
        [](typename impl::forward_element<Cs>::type... vs){
            return std::make_tuple(std::forward<typename impl::forward_element<Cs>::type>(vs)...);
        },
#else
        [](typename impl::container_traits<typename impl::remove_const_reference<Cs>::type>::value_type... vs){
            return std::make_tuple(vs...);
        },
#endif
        std::forward<Cs>(lists)...
    );
}



template <uint Index, class CT,
    class T = typename std::tuple_element<Index, typename impl::container_traits<typename impl::remove_const_reference<CT>::type>::value_type>::type,
    class R = std::vector<T>
>
auto unzip(CT&& list_tuple) ->R
{
    using ET = typename impl::forward_element<CT>::type;

    R result = impl::container_traits<R>::make(list_tuple.size());

    for (auto&& t : std::forward<CT>(list_tuple)){
        impl::container_traits<R>::add_element(result, std::get<Index>(std::forward<ET>(t)));
    }
    return result;
}

namespace impl
{
template<class CT, uint I = 0,
    class CTR = typename impl::remove_const_reference<CT>::type,
    typename std::enable_if<I + 1 == std::tuple_size<typename impl::container_traits<CTR>::value_type>::value, void>::type*& = enabler
>
auto unzipImpl_(CT&& c_tuple)
{
    return std::make_tuple(unzip<I>(std::forward<CT>(c_tuple)));
}
template<class CT, uint I = 0,
    class CTR = typename impl::remove_const_reference<CT>::type,
    typename std::enable_if<I + 1 < std::tuple_size<typename impl::container_traits<CTR>::value_type>::value, void>::type*& = enabler
>
auto unzipImpl_(CT&& c_tuple)
{
    return std::tuple_cat(std::make_tuple(unzip<I>(std::forward<CT>(c_tuple))), impl::unzipImpl_<CT, I + 1>(std::forward<CT>(c_tuple)));
}
}   // impl


template <class CT>
auto unzip(CT&& c_tuple)
{
    return impl::unzipImpl_(std::forward<CT>(c_tuple));
}


#if SIG_ENABLE_TUPLE_ZIP
namespace impl
{
    template <class TC, size_t... Is>
    auto zipImpl_(TC&& t_lists, std::index_sequence<Is...>)
    {
        return zip(std::get<Is>(std::forward<TC>(t_lists))...);
    }
}   // impl


template <class... Cs>
auto zip(std::tuple<Cs...> const& t_lists)
{
    using Indices = std::make_index_sequence<sizeof...(Cs)>;
    return impl::zipImpl_(t_lists, Indices());
}

template <class... Cs>
auto zip(std::tuple<Cs...>&& t_lists)
{
    using Indices = std::make_index_sequence<sizeof...(Cs)>;
    return impl::zipImpl_(std::move(t_lists), Indices());
}
#endif

}
#endif