apply.h

#pragma once

#include "utilities/tuple_like.h"

#include <initializer_list>
#include <tuple>
#include <utility>

namespace util {

template <typename Func, typename... Ts>
constexpr auto apply_params(Func&& func, Ts&&... ts) {
    return func(std::forward<Ts>(ts)...);
}

template <typename Func, typename T, size_t... Ix>
constexpr auto apply(Func&& func, T&& t, std::index_sequence<Ix...>) {
    return apply_params(std::forward<Func>(func),
                        tuple_like_getter<Ix>(std::forward<T>(t))...);
}

template <typename Callback, typename Collection>
constexpr auto apply(Callback&& callback, Collection&& c) {
    return apply(std::forward<Callback>(callback),
                 std::forward<Collection>(c),
                 std::make_index_sequence<
                         tuple_like_size_v<decay_const_ref_t<Collection>>>{});
}


template <typename Callbacks, typename Collection, size_t... Ix>
constexpr auto apply_each(Callbacks&& callbacks,
                          const Collection& c,
                          std::index_sequence<Ix...>) {
    return std::make_tuple(apply(tuple_like_getter<Ix>(callbacks), c)...);
}

template <typename Callbacks, typename Collection>
constexpr auto apply_each(Callbacks&& callbacks, const Collection& c) {
    return apply_each(
            std::forward<Callbacks>(callbacks),
            c,
            std::make_index_sequence<
                    tuple_like_size_v<decay_const_ref_t<Callbacks>>>{});
}

template <typename Callbacks, size_t... Ix>
constexpr auto apply_each(Callbacks&& callbacks, std::index_sequence<Ix...>) {
    return std::make_tuple(tuple_like_getter<Ix>(callbacks)()...);
}

template <typename Callbacks>
constexpr auto apply_each(Callbacks&& callbacks) {
    return apply_each(
            std::forward<Callbacks>(callbacks),
            std::make_index_sequence<
                    tuple_like_size_v<decay_const_ref_t<Callbacks>>>{});
}


template <typename Callbacks, typename Collection, size_t... Ix>
void call_each(Callbacks&& callbacks,
               const Collection& c,
               std::index_sequence<Ix...>) {
    (void)std::initializer_list<int>{
            ((void)apply(tuple_like_getter<Ix>(callbacks), c), 0)...};
}

template <typename Callbacks, typename Collection>
void call_each(Callbacks&& callbacks, const Collection& c) {
    call_each(std::forward<Callbacks>(callbacks),
              c,
              std::make_index_sequence<
                      tuple_like_size_v<decay_const_ref_t<Callbacks>>>{});
}

template <typename Callbacks, size_t... Ix>
void call_each(Callbacks&& callbacks, std::index_sequence<Ix...>) {
    (void)std::initializer_list<int>{
            ((void)tuple_like_getter<Ix>(callbacks)(), 0)...};
}

template <typename Callbacks>
void call_each(Callbacks&& callbacks) {
    call_each(std::forward<Callbacks>(callbacks),
              std::make_index_sequence<
                      tuple_like_size_v<decay_const_ref_t<Callbacks>>>{});
}

}  // namespace util