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 T>
struct is_type_list : public std::false_type {};
 
template <typename... T>
struct is_type_list<Kokkos::Impl::type_list<T...>> : public std::true_type {};
 
template <typename T>
inline constexpr bool is_type_list_v = is_type_list<T>::value;

template <typename...>
struct make_type_list;
 
template <typename T> requires Kokkos::utils::impl::is_type_list_v<T>
struct make_type_list<T>
{
    using type = T;
};
 
template <typename T, typename... Ts>
struct make_type_list<T, Ts...>
{
    using type = Kokkos::Impl::type_list<T, Ts...>;
};
 
template <typename... Args>
using make_type_list_t = typename make_type_list<Args...>::type;

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 U, typename T, typename... Ts>
struct TypeListContains<U, T, Ts...> : public std::disjunction<std::is_same<U, T>, std::is_same<U, Ts>...> {};

template <typename U, typename... Ts>
struct TypeListContains<U, Kokkos::Impl::type_list<Ts...>> : std::disjunction<std::is_same<U, Ts>...> {};
 
template <typename U, typename... TypeList>
inline constexpr bool type_list_contains_v = TypeListContains<U, TypeList...>::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...>> {};
 
template <class Head, class... Tail>
struct TypeListAt<0, Kokkos::Impl::type_list<Head, Tail...>>
{
    using type = Head;
};
 
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...>>;
};
 
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...>;
};
 
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> {};
 
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> {};
 
template <typename T, typename S>
inline constexpr size_t type_list_index_v = TypeListIndex<T, S>::value;

template <template <typename> typename UnaryPred, typename...>
struct type_list_all;

template <template <typename> typename UnaryPred, typename T, typename... Ts>
struct type_list_all<UnaryPred, T, Ts...>
  : public std::conjunction<UnaryPred<T>, UnaryPred<Ts>...> {};

template <template <typename> typename UnaryPred, typename... Ts>
struct type_list_all<UnaryPred, Kokkos::Impl::type_list<Ts...>>
  : public std::conjunction<UnaryPred<Ts>...> {};
 
template <template <typename> typename UnaryPred, typename... TypeList>
inline constexpr bool type_list_all_v = type_list_all<UnaryPred, TypeList...>::value;

template <template <typename> typename UnaryPred, typename...>
struct type_list_any;

#if defined(__NVCC__)
template <template <typename> typename UnaryPred, typename T, typename... Ts>
struct type_list_any<UnaryPred, T, Ts...>
  : public std::bool_constant<UnaryPred<T>::value || (UnaryPred<Ts>::value || ...)> {};
#else
template <template <typename> typename UnaryPred, typename T, typename... Ts>
struct type_list_any<UnaryPred, T, Ts...>
  : public std::disjunction<UnaryPred<T>, UnaryPred<Ts>...> {};
#endif

#if defined(__NVCC__)
template <template <typename> typename UnaryPred, typename... Ts>
struct type_list_any<UnaryPred, Kokkos::Impl::type_list<Ts...>>
  : public std::bool_constant<(UnaryPred<Ts>::value || ...)> {};
#else
template <template <typename> typename UnaryPred, typename... Ts>
struct type_list_any<UnaryPred, Kokkos::Impl::type_list<Ts...>>
  : public std::disjunction<UnaryPred<Ts>...> {};
#endif
 
template <template <typename> typename UnaryPred, typename... TypeList>
inline constexpr bool type_list_any_v = type_list_any<UnaryPred, TypeList...>::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>>{});
}
 
} // namespace Kokkos::utils::impl
 
#endif // KOKKOS_UTILS_IMPL_TYPE_LIST_HPP