type_list.hpp

/*
 * This file is part of libtcspc
 * Copyright 2019-2026 Board of Regents of the University of Wisconsin System
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
#include "common.hpp"
 
#include <concepts>
#include <cstddef>
#include <type_traits>
 
namespace tcspc {

template <typename... Ts> struct type_list {
    type_list() = delete;
};

 
namespace internal {
 
template <typename> struct is_type_list_impl : std::false_type {};
 
template <typename... Ts>
struct is_type_list_impl<type_list<Ts...>> : std::true_type {};
 
} // namespace internal


template <typename T>
concept type_list_like = internal::is_type_list_impl<T>::value;

 
namespace internal {
 
template <typename EventList>
inline constexpr bool is_copy_constructible_list_v = false;
 
template <typename... Es>
inline constexpr bool is_copy_constructible_list_v<type_list<Es...>> =
    (std::copy_constructible<Es> && ...);
 
template <typename EventList>
inline constexpr bool is_move_constructible_list_v = false;
 
template <typename... Es>
inline constexpr bool is_move_constructible_list_v<type_list<Es...>> =
    (std::move_constructible<Es> && ...);
 
template <typename EventList>
inline constexpr bool is_move_assignable_list_v = false;
 
template <typename... Es>
inline constexpr bool is_move_assignable_list_v<type_list<Es...>> =
    (std::is_move_assignable_v<Es> && ...);
 
template <typename EventList>
inline constexpr bool is_equality_comparable_list_v = false;
 
template <typename... Es>
inline constexpr bool is_equality_comparable_list_v<type_list<Es...>> =
    (std::equality_comparable<Es> && ...);
 
} // namespace internal



template <typename TypeList> struct type_list_size;

 
template <typename... Ts>
struct type_list_size<type_list<Ts...>>
    : std::integral_constant<std::size_t, sizeof...(Ts)> {};


template <typename TypeList>
inline constexpr std::size_t type_list_size_v =
    type_list_size<TypeList>::value;



template <typename TypeList> struct type_list_singleton_element;

 
template <typename T>
struct type_list_singleton_element<type_list<T>> : std::type_identity<T> {};


template <typename TypeList>
using type_list_singleton_element_t =
    type_list_singleton_element<TypeList>::type;


 
namespace internal {
 
template <typename TypeList, typename Type> struct type_list_contains_impl;
 
template <typename Type, typename... Ts>
struct type_list_contains_impl<type_list<Ts...>, Type>
    : std::bool_constant<(std::same_as<Type, Ts> || ...)> {};
 
} // namespace internal


template <typename Type, typename TypeList>
concept type_list_member =
    internal::type_list_contains_impl<TypeList, Type>::value;

 
namespace internal {
 
template <typename Type, typename TypeList>
struct is_convertible_to_type_list_member_impl;
 
template <typename Type, typename... Ts>
struct is_convertible_to_type_list_member_impl<Type, type_list<Ts...>>
    : std::bool_constant<(std::convertible_to<Type, Ts> || ...)> {};
 
} // namespace internal


template <typename Type, typename TypeList>
concept convertible_to_type_list_member =
    internal::is_convertible_to_type_list_member_impl<Type, TypeList>::value;


template <typename TL0, typename TL1> struct type_list_is_subset;

 
template <typename... T0s, typename TL1>
struct type_list_is_subset<type_list<T0s...>, TL1>
    : std::bool_constant<(type_list_member<T0s, TL1> && ...)> {};


template <typename TL0, typename TL1>
inline constexpr bool type_list_is_subset_v =
    type_list_is_subset<TL0, TL1>::value;



template <typename TL0, typename TL1>
struct type_list_is_equal_set
    : std::conjunction<type_list_is_subset<TL0, TL1>,
                       type_list_is_subset<TL1, TL0>> {};

template <typename TL0, typename TL1>
inline constexpr bool type_list_is_equal_set_v =
    type_list_is_equal_set<TL0, TL1>::value;


 
namespace internal {
 
template <typename Dest, typename Src> struct unique_type_list_impl;
 
template <typename... Ds>
struct unique_type_list_impl<type_list<Ds...>, type_list<>>
    : std::type_identity<type_list<Ds...>> {};
 
template <typename... Ds, typename T, typename... Ts>
struct unique_type_list_impl<type_list<Ds...>, type_list<T, Ts...>>
    : std::conditional_t<
          type_list_member<T, type_list<Ds...>>,
          unique_type_list_impl<type_list<Ds...>, type_list<Ts...>>,
          unique_type_list_impl<type_list<Ds..., T>, type_list<Ts...>>> {};
 
} // namespace internal

template <typename TypeList>
struct unique_type_list
    : internal::unique_type_list_impl<type_list<>, TypeList> {};

template <typename TypeList>
using unique_type_list_t = unique_type_list<TypeList>::type;


 
namespace internal {
 
template <typename Dest, typename Src0, typename Src1>
struct type_list_union_impl;
 
template <typename... Ds>
struct type_list_union_impl<type_list<Ds...>, type_list<>, type_list<>>
    : std::type_identity<type_list<Ds...>> {};
 
template <typename... Ds, typename S1, typename... S1s>
struct type_list_union_impl<type_list<Ds...>, type_list<>,
                            type_list<S1, S1s...>>
    : std::conditional_t<
          type_list_member<S1, type_list<Ds...>>,
          type_list_union_impl<type_list<Ds...>, type_list<>,
                               type_list<S1s...>>,
          type_list_union_impl<type_list<Ds..., S1>, type_list<>,
                               type_list<S1s...>>> {};
 
template <typename... Ds, typename S0, typename... S0s, typename... S1s>
struct type_list_union_impl<type_list<Ds...>, type_list<S0, S0s...>,
                            type_list<S1s...>>
    : std::conditional_t<
          type_list_member<S0, type_list<Ds...>>,
          type_list_union_impl<type_list<Ds...>, type_list<S0s...>,
                               type_list<S1s...>>,
          type_list_union_impl<type_list<Ds..., S0>, type_list<S0s...>,
                               type_list<S1s...>>> {};
 
} // namespace internal

template <typename TL0, typename TL1>
struct type_list_union
    : internal::type_list_union_impl<type_list<>, TL0, TL1> {};

template <typename TL0, typename TL1>
using type_list_union_t = type_list_union<TL0, TL1>::type;


 
namespace internal {
 
template <typename Dest, typename Src0, typename Src1>
struct type_list_intersection_impl;
 
template <typename... Ds, typename... S1s>
struct type_list_intersection_impl<type_list<Ds...>, type_list<>,
                                   type_list<S1s...>>
    : std::type_identity<type_list<Ds...>> {};
 
template <typename... Ds, typename S0, typename... S0s, typename... S1s>
struct type_list_intersection_impl<type_list<Ds...>, type_list<S0, S0s...>,
                                   type_list<S1s...>>
    : std::conditional_t<
          type_list_member<S0, type_list<S1s...>>,
          type_list_intersection_impl<type_list<Ds..., S0>, type_list<S0s...>,
                                      type_list<S1s...>>,
          type_list_intersection_impl<type_list<Ds...>, type_list<S0s...>,
                                      type_list<S1s...>>> {};
 
} // namespace internal

template <typename TL0, typename TL1>
struct type_list_intersection
    : internal::type_list_intersection_impl<type_list<>, TL0, TL1> {};

template <typename TL0, typename TL1>
using type_list_intersection_t = type_list_intersection<TL0, TL1>::type;


 
namespace internal {
 
template <typename Dest, typename Src0, typename Src1>
struct type_list_set_difference_impl;
 
template <typename... Ds, typename... S1s>
struct type_list_set_difference_impl<type_list<Ds...>, type_list<>,
                                     type_list<S1s...>>
    : std::type_identity<type_list<Ds...>> {};
 
template <typename... Ds, typename S0, typename... S0s, typename... S1s>
struct type_list_set_difference_impl<type_list<Ds...>, type_list<S0, S0s...>,
                                     type_list<S1s...>>
    : std::conditional_t<
          type_list_member<S0, type_list<S1s...>>,
          type_list_set_difference_impl<type_list<Ds...>, type_list<S0s...>,
                                        type_list<S1s...>>,
          type_list_set_difference_impl<
              type_list<Ds..., S0>, type_list<S0s...>, type_list<S1s...>>> {};
 
} // namespace internal

template <typename TL0, typename TL1>
struct type_list_set_difference
    : internal::type_list_set_difference_impl<type_list<>, TL0, TL1> {};

template <typename TL0, typename TL1>
using type_list_set_difference_t = type_list_set_difference<TL0, TL1>::type;

 
} // namespace tcspc