type_list.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
 
namespace tsm::detail {
 
template<typename... Ts>
struct type_list {};
 
struct type_list_traits {
    template<typename Ts>
    struct accepts : std::false_type {};
 
    template<typename... Ts>
    struct accepts<type_list<Ts...>> : std::true_type {};
 
    template<template<typename> class Predicate, typename Ts>
    struct all_satisfy : std::false_type {};
 
    template<template<typename> class Predicate, typename... Ts>
    struct all_satisfy<Predicate, type_list<Ts...>>
      : std::bool_constant<(Predicate<Ts>::value && ...)> {};
 
    template<template<typename> class Predicate, typename Ts>
    struct any_satisfy : std::false_type {};
 
    template<template<typename> class Predicate, typename... Ts>
    struct any_satisfy<Predicate, type_list<Ts...>>
      : std::bool_constant<(false || ... || Predicate<Ts>::value)> {};
};
 
template<typename Ts>
concept type_list_like = type_list_traits::accepts<Ts>::value;
 
template<typename T>
struct front_type;
 
template<typename T, typename... Ts>
struct front_type<type_list<T, Ts...>> {
    using type = T;
};
 
template<typename T>
using front_type_t = typename front_type<T>::type;
 
template<typename List>
struct empty_type_list;
 
template<typename... Ts>
struct empty_type_list<type_list<Ts...>>
  : std::bool_constant<sizeof...(Ts) == 0U> {};
 
template<typename List>
inline constexpr bool empty_type_list_v = empty_type_list<List>::value;
 
template<std::size_t Index, typename List>
struct type_at;
 
template<std::size_t Index, typename... Ts>
struct type_at<Index, type_list<Ts...>> {
    using type = std::tuple_element_t<Index, std::tuple<Ts...>>;
};
 
template<std::size_t Index, typename List>
using type_at_t = typename type_at<Index, List>::type;
 
template<typename T>
struct as_tuple;
 
template<typename... Ts>
struct as_tuple<std::tuple<Ts...>> {
    using type = std::tuple<Ts...>;
};
 
template<typename... Ts>
struct as_tuple<type_list<Ts...>> {
    using type = std::tuple<Ts...>;
};
 
template<typename T>
using as_tuple_t = typename as_tuple<T>::type;
 
template<typename T, typename... Ts>
consteval bool contains_type(type_list<Ts...>) {
    return (std::is_same_v<T, Ts> || ...);
}
 
template<typename T, typename... Ts>
consteval bool contains_type(std::tuple<Ts...>) {
    return (std::is_same_v<T, Ts> || ...);
}
 
template<typename T, typename... Ts>
consteval std::size_t max_sizeof(type_list<T, Ts...>) {
    std::size_t result = sizeof(T);
    ((result = sizeof(Ts) > result ? sizeof(Ts) : result), ...);
    return result;
}
 
template<typename T, typename... Ts>
consteval std::size_t max_sizeof(std::tuple<T, Ts...>) {
    return max_sizeof(type_list<T, Ts...>{});
}
 
template<typename T, typename... Ts>
consteval std::size_t max_alignof(type_list<T, Ts...>) {
    std::size_t result = alignof(T);
    ((result = alignof(Ts) > result ? alignof(Ts) : result), ...);
    return result;
}
 
template<typename T, typename... Ts>
consteval std::size_t max_alignof(std::tuple<T, Ts...>) {
    return max_alignof(type_list<T, Ts...>{});
}
 
template<typename T>
struct as_type_list;
 
template<typename... Ts>
struct as_type_list<type_list<Ts...>> {
    using type = type_list<Ts...>;
};
 
template<typename... Ts>
struct as_type_list<std::tuple<Ts...>> {
    using type = type_list<Ts...>;
};
 
template<typename T>
using as_type_list_t = typename as_type_list<T>::type;
 
template<typename... Lists>
struct concat_type_lists;
 
template<>
struct concat_type_lists<> {
    using type = type_list<>;
};
 
template<typename... Ts>
struct concat_type_lists<type_list<Ts...>> {
    using type = type_list<Ts...>;
};
 
template<typename... As, typename... Bs, typename... Rest>
struct concat_type_lists<type_list<As...>, type_list<Bs...>, Rest...> {
    using type =
      typename concat_type_lists<type_list<As..., Bs...>, Rest...>::type;
};
 
template<typename... Lists>
using concat_type_lists_t = typename concat_type_lists<Lists...>::type;
 
template<template<typename> class Predicate, typename List>
struct filter_type_list;
 
template<template<typename> class Predicate, typename... Ts>
struct filter_type_list<Predicate, type_list<Ts...>> {
    template<typename T>
    using keep_one =
      std::conditional_t<Predicate<T>::value, type_list<T>, type_list<>>;
 
    using type = concat_type_lists_t<keep_one<Ts>...>;
};
 
template<template<typename> class Predicate, typename List>
using filter_type_list_t = typename filter_type_list<Predicate, List>::type;
 
template<template<class> class Wrapper, typename Tuple>
struct wrap_type_impl;
 
template<template<class> class Wrapper, typename... Ts>
struct wrap_type_impl<Wrapper, std::tuple<Ts...>> {
    using type = std::tuple<typename Wrapper<Ts>::type...>;
};
 
template<template<class> class Wrapper, typename Tuple>
using wrap_type = typename wrap_type_impl<Wrapper, Tuple>::type;
 
template<typename T, typename Tuple>
struct append_unique_impl;
 
template<typename T>
struct append_unique_impl<T, std::tuple<>> {
    using type = std::tuple<T>;
};
 
template<typename T>
struct append_unique_impl<T, type_list<>> {
    using type = type_list<T>;
};
 
template<typename T, typename... Ts>
struct append_unique_impl<T, std::tuple<Ts...>> {
    using type = std::conditional_t<!(std::is_same_v<T, Ts> || ...),
                                    std::tuple<Ts..., T>,
                                    std::tuple<Ts...>>;
};
 
template<typename T, typename... Ts>
struct append_unique_impl<T, type_list<Ts...>> {
    using type = std::conditional_t<!(std::is_same_v<T, Ts> || ...),
                                    type_list<Ts..., T>,
                                    type_list<Ts...>>;
};
 
template<typename T, typename Tuple>
using append_unique = typename append_unique_impl<T, Tuple>::type;
 
template<typename List>
struct type_set;
 
template<typename... Ts>
struct type_set<type_list<Ts...>> {
    using list = type_list<Ts...>;
 
    template<typename T>
    using insert = type_set<append_unique<T, list>>;
 
    template<typename T>
    static consteval bool contains() {
        return contains_type<T>(list{});
    }
};
 
template<typename Set>
using type_set_list_t = typename Set::list;
 
template<typename List, typename StateSet>
struct retain_if_in_set;
 
template<typename StateSet, typename... Ts>
struct retain_if_in_set<type_list<Ts...>, StateSet> {
    template<typename State>
    using keep_one =
      std::conditional_t<StateSet::template contains<State>(),
                         type_list<State>,
                         type_list<>>;
 
    using type = concat_type_lists_t<keep_one<Ts>...>;
};
 
template<typename List, typename StateSet>
using retain_if_in_set_t = typename retain_if_in_set<List, StateSet>::type;
 
template<typename... Ts>
struct type_map {};
 
template<typename Key, typename Value>
struct type_map_entry {
    using key = Key;
    using value = Value;
};
 
template<typename Key, typename Map>
struct type_map_lookup;
 
template<typename Key>
struct type_map_lookup<Key, type_map<>> {
    using type = void;
};
 
template<typename Key, typename First, typename... Rest>
struct type_map_lookup<Key, type_map<First, Rest...>> {
    using type = std::conditional_t<
      std::is_same_v<Key, typename First::key>,
      typename First::value,
      typename type_map_lookup<Key, type_map<Rest...>>::type>;
};
 
template<typename Key, typename Map>
using type_map_lookup_t = typename type_map_lookup<Key, Map>::type;
 
template<typename EntryList>
struct type_map_from_entries;
 
template<typename... Entries>
struct type_map_from_entries<type_list<Entries...>> {
    using type = type_map<Entries...>;
};
 
template<typename EntryList>
using type_map_from_entries_t =
  typename type_map_from_entries<EntryList>::type;
 
template<typename Ts, typename Us>
struct unique_tuple_impl;
 
template<typename... Us>
struct unique_tuple_impl<std::tuple<>, std::tuple<Us...>> {
    using type = std::tuple<Us...>;
};
 
template<typename T, typename... Ts, typename... Us>
struct unique_tuple_impl<std::tuple<T, Ts...>, std::tuple<Us...>> {
    using type =
      typename unique_tuple_impl<std::tuple<Ts...>,
                                 append_unique<T, std::tuple<Us...>>>::type;
};
 
template<typename... Us>
struct unique_tuple_impl<type_list<>, type_list<Us...>> {
    using type = type_list<Us...>;
};
 
template<typename T, typename... Ts, typename... Us>
struct unique_tuple_impl<type_list<T, Ts...>, type_list<Us...>> {
    using type =
      typename unique_tuple_impl<type_list<Ts...>,
                                 append_unique<T, type_list<Us...>>>::type;
};
 
template<typename Ts, typename Us = std::tuple<>>
struct unique_tuple {
    using type = typename unique_tuple_impl<Ts, Us>::type;
};
 
template<typename Ts>
using unique_tuple_t = typename unique_tuple<Ts>::type;
 
} // namespace tsm::detail