type_list.hpp

Go to the documentation of this file.

#ifndef KOKKOS_UTILS_IMPL_TYPE_LIST_HPP
#define KOKKOS_UTILS_IMPL_TYPE_LIST_HPP
 
#include "impl/Kokkos_Utilities.hpp"

 
namespace Kokkos::utils::impl
{

template <typename>
struct TypeListSize;
 
template <typename... Ts>
struct TypeListSize<Kokkos::Impl::type_list<Ts...>> : std::integral_constant<size_t, sizeof...(Ts)> {};
 
template <typename T>
inline constexpr size_t type_list_size_v = TypeListSize<T>::value;

template <typename, typename>
struct TypeListContains;
 
template <typename T, typename... Ts>
struct TypeListContains<T, Kokkos::Impl::type_list<Ts...>> : std::disjunction<std::is_same<T, Ts>...> {};
 
template <typename T, typename S>
inline constexpr bool type_list_contains_v = TypeListContains<T, S>::value;

template <size_t, typename>
struct TypeListAt;
 
template <size_t I, typename Head, typename... Tail>
struct TypeListAt<I, Kokkos::Impl::type_list<Head, Tail...>>
  : TypeListAt<I - 1, Kokkos::Impl::type_list<Tail...>> {};
struct TypeListAt<I, Kokkos::Impl::type_list<Head, Tail...>> {…};
 
template <class Head, class... Tail>
struct TypeListAt<0, Kokkos::Impl::type_list<Head, Tail...>>
{
    using type = Head;
};
struct TypeListAt<0, Kokkos::Impl::type_list<Head, Tail...>> {…};
 
template <size_t I, typename T>
using type_list_at_t = typename TypeListAt<I, T>::type;

template <template <typename> typename, typename>
struct TransformTypeList;
 
template <template <typename> typename TransformerType, typename... Ts>
struct TransformTypeList<TransformerType, Kokkos::Impl::type_list<Ts...>>
{
    using type = Kokkos::Impl::concat_type_list_t<Kokkos::Impl::type_list<typename TransformerType<Ts>::type...>>;
};
struct TransformTypeList<TransformerType, Kokkos::Impl::type_list<Ts...>> {…};
 
template <template <typename> typename TransformerType, typename T>
using transform_type_list_t = typename TransformTypeList<TransformerType, T>::type;

template <typename>
struct TypeListToTuple;
 
template <typename... Ts>
struct TypeListToTuple<Kokkos::Impl::type_list<Ts...>>
{
    using type = std::tuple<Ts...>;
};
struct TypeListToTuple<Kokkos::Impl::type_list<Ts...>> {…};
 
template <typename T>
using type_list_to_tuple_t = typename TypeListToTuple<T>::type;

template <typename, typename>
struct TypeListIndex;
 
template <typename T, typename... Ts>
struct TypeListIndex<T, Kokkos::Impl::type_list<T, Ts...>>
  : std::integral_constant<size_t, 0> {};
struct TypeListIndex<T, Kokkos::Impl::type_list<T, Ts...>> {…};
 
template <typename T, typename Head, typename... Ts>
struct TypeListIndex<T, Kokkos::Impl::type_list<Head, Ts...>>
  : std::integral_constant<size_t, 1 + TypeListIndex<T, Kokkos::Impl::type_list<Ts...>>::value> {};
struct TypeListIndex<T, Kokkos::Impl::type_list<Head, Ts...>> {…};
 
template <typename T, typename S>
inline constexpr size_t type_list_index_v = TypeListIndex<T, S>::value;

template <typename TypeList, typename Callable>
constexpr void for_each(Callable callable)
{
    [&] <size_t... Is>(std::index_sequence<Is...>) constexpr {
        (callable.template operator()<type_list_at_t<Is, TypeList>>(), ...);
    }(std::make_index_sequence<type_list_size_v<TypeList>>{});
}
constexpr void for_each(Callable callable) {…}
 
} // namespace Kokkos::utils::impl
namespace Kokkos::utils::impl {…}
 
#endif // KOKKOS_UTILS_IMPL_TYPE_LIST_HPP