tuple.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#ifndef HIPIPE_CORE_TUPLE_UTILS_HPP
#define HIPIPE_CORE_TUPLE_UTILS_HPP
 
#include <range/v3/core.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/range/primitives.hpp>
 
#include <experimental/tuple>
#include <ostream>
#include <type_traits>
#include <vector>
 
namespace hipipe::utility {
 
template<typename T1, typename T2, typename... Ts>
struct variadic_find : std::integral_constant<std::size_t, variadic_find<T1, Ts...>{}+1> {
};
 
template<typename T, typename... Ts>
struct variadic_find<T, T, Ts...> : std::integral_constant<std::size_t, 0> {
};
 
template<std::size_t N, typename... Ts>
struct maybe_tuple_impl {
    using type = std::tuple<Ts...>;
};
 
template<typename T>
struct maybe_tuple_impl<1, T> {
    using type = T;
};
 
template<typename... Ts>
using maybe_tuple = typename maybe_tuple_impl<sizeof...(Ts), Ts...>::type;
 
template<std::size_t Value, std::size_t... Is>
constexpr std::index_sequence<(Value + Is)...> plus(std::index_sequence<Is...>)
{
    return {};
}
 
template <std::size_t Offset, std::size_t N>
using make_offset_index_sequence = decltype(plus<Offset>(std::make_index_sequence<N>{}));
 
// tuple_for_each //
 
namespace detail {
 
    template<typename Fun, typename Tuple, std::size_t... Is>
    constexpr Fun tuple_for_each_impl(Tuple&& tuple, Fun&& fun, std::index_sequence<Is...>)
    {
        (..., (std::invoke(fun, std::get<Is>(std::forward<Tuple>(tuple)))));
        return fun;
    }
 
}  // namespace detail
 
template<typename Tuple, typename Fun>
constexpr auto tuple_for_each(Tuple&& tuple, Fun&& fun)
{
    constexpr std::size_t tuple_size = std::tuple_size<std::decay_t<Tuple>>::value;
    return detail::tuple_for_each_impl(std::forward<Tuple>(tuple),
                                       std::forward<Fun>(fun),
                                       std::make_index_sequence<tuple_size>{});
}
 
// tuple_transform //
 
namespace detail {
 
    template<typename Tuple, typename Fun, std::size_t... Is>
    constexpr auto tuple_transform_impl(Tuple&& tuple, Fun&& fun, std::index_sequence<Is...>)
    {
        return std::make_tuple(std::invoke(fun, std::get<Is>(std::forward<Tuple>(tuple)))...);
    }
 
}  // end namespace detail
 
template<typename Tuple, typename Fun>
constexpr auto tuple_transform(Tuple&& tuple, Fun&& fun)
{
    constexpr std::size_t tuple_size = std::tuple_size<std::decay_t<Tuple>>::value;
    return detail::tuple_transform_impl(std::forward<Tuple>(tuple),
                                        std::forward<Fun>(fun),
                                        std::make_index_sequence<tuple_size>{});
}
 
template<typename T, typename Tuple = void>
struct tuple_contains;
 
template<typename T, typename... Types>
struct tuple_contains<T, std::tuple<Types...>>
  : std::disjunction<std::is_same<std::decay_t<T>, std::decay_t<Types>>...> {
};
 
template<typename Tuple, size_t... Is>
std::ostream& tuple_print(std::ostream& out, const Tuple& tuple, std::index_sequence<Is...>)
{
    out << "(";
    (..., (out << (Is == 0 ? "" : ", ") << std::get<Is>(tuple)));
    out << ")";
    return out;
}
 
template<typename... Ts>
std::ostream& operator<<(std::ostream& out, const std::tuple<Ts...>& tuple)
{
    return utility::tuple_print(out, tuple, std::make_index_sequence<sizeof...(Ts)>{});
}
 
// unzip //
 
namespace detail {
 
    // wrap each type of a tuple in std::vector, i.e., make a tuple of empty vectors
    template<typename Tuple, std::size_t... Is>
    auto vectorize_tuple(std::index_sequence<Is...>)
    {
        return std::make_tuple(std::vector<std::tuple_element_t<Is, std::decay_t<Tuple>>>()...);
    }
 
    // push elements from the given tuple to the corresponding vectors in a tuple of vectors
    template<typename ToR, typename Tuple, std::size_t... Is>
    void push_unzipped(ToR& tuple_of_ranges, Tuple&& tuple, std::index_sequence<Is...>)
    {
        (..., (std::get<Is>(tuple_of_ranges).push_back(std::get<Is>(std::forward<Tuple>(tuple)))));
    }
 
    // if the size of the given range is known, return it, otherwise return 0
    CPP_template(class Rng)(requires ranges::sized_range<Rng>)
    std::size_t safe_reserve_size(Rng&& rng)
    {
        return ranges::size(rng);
    }
    CPP_template(class Rng)(requires !ranges::sized_range<Rng>)
    std::size_t safe_reserve_size(Rng&& rng)
    {
        return 0;
    }
 
    template<typename Rng>
    auto unzip_impl(Rng& range_of_tuples)
    {
        using tuple_type = ranges::range_value_t<Rng>;
        constexpr auto tuple_size = std::tuple_size<tuple_type>{};
        constexpr auto indices = std::make_index_sequence<tuple_size>{};
        std::size_t reserve_size = detail::safe_reserve_size(range_of_tuples);
 
        auto tuple_of_ranges = detail::vectorize_tuple<tuple_type>(indices);
        utility::tuple_for_each(
          tuple_of_ranges, [reserve_size](auto& rng) { rng.reserve(reserve_size); });
 
        for (auto& v : range_of_tuples) {
            detail::push_unzipped(tuple_of_ranges, std::move(v), indices);
        }
 
        return tuple_of_ranges;
    }
 
}  // namespace detail
 
CPP_template(class Rng)(requires ranges::range<Rng> && !ranges::view_<Rng>)
auto unzip(Rng range_of_tuples)
{
    // copy the given container and move elements out of it
    return detail::unzip_impl(range_of_tuples);
}
 
CPP_template(class Rng)(requires ranges::view_<Rng>)
auto unzip(Rng view_of_tuples)
{
    return utility::unzip(ranges::to_vector(view_of_tuples));
}
 
// maybe unzip //
 
namespace detail {
 
    template<bool Enable>
    struct unzip_if_impl
    {
        template<typename Rng>
        static decltype(auto) impl(Rng&& rng)
        {
            return utility::unzip(std::forward<Rng>(rng));
        }
    };
 
    template<>
    struct unzip_if_impl<false>
    {
        template<typename Rng>
        static Rng&& impl(Rng&& rng)
        {
            return std::forward<Rng>(rng);
        }
    };
 
}  // namespace detail
 
template<bool Enable, typename RangeT>
decltype(auto) unzip_if(RangeT&& range)
{
    return detail::unzip_if_impl<Enable>::impl(std::forward<RangeT>(range));
}
 
// maybe untuple //
 
namespace detail {
 
    template<std::size_t Size>
    struct maybe_untuple_impl
    {
        template<typename Tuple>
        static Tuple&& impl(Tuple&& tuple)
        {
            return std::forward<Tuple>(tuple);
        }
    };
 
    template<>
    struct maybe_untuple_impl<1>
    {
        template<typename Tuple>
        static decltype(auto) impl(Tuple&& tuple)
        {
            return std::get<0>(std::forward<Tuple>(tuple));
        }
    };
 
}  // namespace detail
 
template<typename Tuple>
decltype(auto) maybe_untuple(Tuple&& tuple)
{
    constexpr std::size_t tuple_size = std::tuple_size<std::decay_t<Tuple>>::value;
    return detail::maybe_untuple_impl<tuple_size>::impl(std::forward<Tuple>(tuple));
}
 
// times with index //
 
namespace detail {
 
    template<typename Fun, std::size_t... Is>
    constexpr Fun times_with_index_impl(Fun&& fun, std::index_sequence<Is...>)
    {
        (..., (std::invoke(fun, std::integral_constant<std::size_t, Is>{})));
        return fun;
    }
 
}  // namespace detail
 
template<std::size_t N, typename Fun>
constexpr Fun times_with_index(Fun&& fun)
{
    return detail::times_with_index_impl(std::forward<Fun>(fun), std::make_index_sequence<N>{});
}
 
template <typename Tuple, typename Fun>
constexpr auto tuple_for_each_with_index(Tuple&& tuple, Fun&& fun)
{
    return utility::times_with_index<std::tuple_size<std::decay_t<Tuple>>{}>(
      [&fun, &tuple](auto index) {
          std::invoke(fun, std::get<index>(tuple), index);
    });
}
 
// transform with index //
 
namespace detail {
 
    template <typename Fun, typename Tuple, std::size_t... Is>
    constexpr auto tuple_transform_with_index_impl(Tuple&& tuple, Fun&& fun,
                                                   std::index_sequence<Is...>)
    {
        return std::make_tuple(std::invoke(fun, std::get<Is>(std::forward<Tuple>(tuple)),
                                           std::integral_constant<std::size_t, Is>{})...);
    }
 
}  // namespace detail
 
template <typename Tuple, typename Fun>
constexpr auto tuple_transform_with_index(Tuple&& tuple, Fun&& fun)
{
    return detail::tuple_transform_with_index_impl(
      std::forward<Tuple>(tuple), std::forward<Fun>(fun),
      std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>{}>{});
}
 
}  // namespace hipipe::utility
 
#endif