AMReX_TypeList.H

Go to the documentation of this file.

#ifndef AMREX_TYPELIST_H_
#define AMREX_TYPELIST_H_
#include <AMReX_Config.H>
 
#include <type_traits>
#include <utility>
 
namespace amrex {
 
template <class... Ts>
struct TypeList
{
    static constexpr std::size_t size () noexcept { return sizeof...(Ts); }
};
 
namespace detail {
    template <std::size_t I, typename T> struct TypeListGet;
 
    template <std::size_t I, typename Head, typename... Tail>
    struct TypeListGet<I, TypeList<Head, Tail...> >
        : TypeListGet<I-1, TypeList<Tail...> > {};
 
    template <typename Head, typename... Tail>
    struct TypeListGet<0, TypeList<Head, Tail...> > {
        using type = Head;
    };
}
 
template <std::size_t I, typename T>
using TypeAt = typename detail::TypeListGet<I,T>::type;
 
namespace detail
{
    template <typename TL, typename F, std::size_t...N>
    constexpr void for_each_impl (F const&f, std::index_sequence<N...>)
    {
        (f(TypeAt<N,TL>{}), ...);
    }
 
    template <typename TL, typename F, std::size_t...N>
    constexpr bool for_each_until_impl (F const&f, std::index_sequence<N...>)
    {
        return (f(TypeAt<N,TL>{}) || ...);
    }
}
 
template <typename... Ts, typename F>
constexpr void
ForEach (TypeList<Ts...>, F&& f)
{
    detail::for_each_impl<TypeList<Ts...>>
        (std::forward<F>(f), std::make_index_sequence<sizeof...(Ts)>());
}
 
template <typename... Ts, typename F>
constexpr bool
ForEachUntil (TypeList<Ts...>, F&& f)
{
    return detail::for_each_until_impl<TypeList<Ts...>>
        (std::forward<F>(f), std::make_index_sequence<sizeof...(Ts)>());
}
 
template <typename... As, typename... Bs>
constexpr auto operator+ (TypeList<As...>, TypeList<Bs...>) {
    return TypeList<As..., Bs...>{};
}
 
template <typename... Ls, typename A>
constexpr auto single_product (TypeList<Ls...>, A) {
    return TypeList<decltype(Ls{} + TypeList<A>{})...>{};
}
 
template <typename LLs, typename... As>
constexpr auto operator* (LLs, TypeList<As...>) {
    return (TypeList<>{} + ... + single_product(LLs{}, As{}));
}
 
template <typename... Ls>
constexpr auto CartesianProduct (Ls...) {
    return (TypeList<TypeList<>>{} * ... * Ls{});
}
 
template <class T, std::size_t N>
struct TypeArray {
    using Type = T;
    static constexpr std::size_t size () noexcept { return N; }
};
 
namespace detail {
    // return TypeList<T, T, T, T, ... (N times)> by using the fast power algorithm
    template <class T, std::size_t N>
    constexpr auto SingleTypeMultiplier_impl () {
        if constexpr (N == 0) {
            return TypeList<>{};
        } else if constexpr (N == 1) {
            return TypeList<T>{};
        } else if constexpr (N % 2 == 0) {
            return SingleTypeMultiplier_impl<T, N / 2>() + SingleTypeMultiplier_impl<T, N / 2>();
        } else {
            return SingleTypeMultiplier_impl<T, N - 1>() + TypeList<T>{};
        }
    }
 
    // overload of SingleTypeMultiplier for multiple types:
    // convert T[N] to  T, T, T, T, ... (N times with N >= 1)
    template <class T, std::size_t N>
    constexpr auto SingleTypeMultiplier (const T (&)[N]) {
        return SingleTypeMultiplier_impl<T, N>();
    }
 
    // overload of SingleTypeMultiplier for multiple types:
    // convert TypeArray<T,N> to  T, T, T, T, ... (N times with N >= 0)
    // Note that only this overload works with N = 0
    template <class T, std::size_t N>
    constexpr auto SingleTypeMultiplier (TypeArray<T, N>) {
        return SingleTypeMultiplier_impl<T, N>();
    }
 
    // overload of SingleTypeMultiplier for one regular type
    template <class T>
    constexpr auto SingleTypeMultiplier (T) {
        return TypeList<T>{};
    }
 
    // apply the types of the input TypeList as template arguments to TParam
    template <template <class...> class TParam, class... Args>
    constexpr auto TApply (TypeList<Args...>) {
        return TypeList<TParam<Args...>>{};
    }
}
 
template <template <class...> class TParam, class... Types>
using TypeMultiplier = TypeAt<0, decltype(detail::TApply<TParam>(
    (TypeList<>{} + ... + detail::SingleTypeMultiplier(std::declval<Types>()))
))>;
 
template <typename T>
struct ToTypeList { using type = TypeList<T>; };
 
template <typename... Ts>
struct ToTypeList<TypeList<Ts...>> { using type = TypeList<Ts...>; };
 
template <typename T>
using ToTypeList_t = typename ToTypeList<T>::type;
 
template <typename T> struct IsTypeList : std::false_type {};
template <typename... Ts> struct IsTypeList<TypeList<Ts...>> : std::true_type {};
template <typename T> inline constexpr bool IsTypeList_v = IsTypeList<T>::value;
 
}
 
#endif