types.h

Go to the documentation of this file.

#ifndef KOUTIL_UTIL_TYPES_H
#define KOUTIL_UTIL_TYPES_H
 
#include <array>
#include <cassert>
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
namespace koutil::type {
 
template <typename... T> struct types {
    static constexpr std::size_t size = sizeof...(T);
};
 
template <typename T> struct are_types : std::false_type { };
 
template <typename... Types> struct are_types<types<Types...>> : std::true_type { };
 
template <typename T> inline constexpr bool are_types_v = are_types<T>::value;
 
template <typename T>
concept types_concept = are_types_v<T>;
 
template <types_concept T, types_concept U> struct types_cat;
 
template <typename... T, typename... U> struct types_cat<types<T...>, types<U...>> {
    using type = types<T..., U...>;
};
 
template <types_concept T, types_concept U> using types_cat_t = types_cat<T, U>::type;
 
template <typename T>
concept types_transform = requires() {
    typename T::template transform<int>;
    typename T::template transform<int, int>;
    typename T::template transform<int, int, int, int, int>;
};
 
template <typename T>
concept types_container = requires() { typename T::template container<int>; };
 
struct types_transforms {
    struct tuple {
        template <typename... Types> using transform = std::tuple<Types...>;
    };
 
    struct variant {
        template <typename... Types> using transform = std::variant<Types...>;
    };
 
    struct reference {
        template <typename... Types> using transform = types<Types&...>;
    };
 
    struct constant {
        template <typename... Types> using transform = types<const Types...>;
    };
 
    /*
     * @brief Provides a `const T&` transform.
     */
    struct constant_reference {
        template <typename... Types> using transform = types<const Types&...>;
    };
 
    struct vector_reference {
        template <typename... Types> using transform = types<typename std::vector<Types>::reference...>;
    };
 
    /*
     * @brief Provides a `std::vector<T>::const_reference` transform.
     */
    struct vector_const_reference {
        template <typename... Types> using transform = types<typename std::vector<Types>::const_reference...>;
    };
};
 
struct types_containers {
    struct vector {
        template <typename T> using container = std::vector<T>;
    };
};
 
template <types_concept Types> struct types_count;
 
template <typename... Types> struct types_count<types<Types...>> {
    template <typename T> static constexpr std::size_t value = 0 + (std::is_same_v<T, Types> + ...);
};
 
namespace detail {
    template <typename T, typename... Other> consteval bool contains_type() {
        return (std::is_same_v<T, Other> || ...);
    }
 
    template <typename... Types> struct unique_types_impl;
 
    template <typename T> struct unique_types_impl<T> {
        using type = types<T>;
    };
 
    template <typename T, typename... Other> struct unique_types_impl<T, Other...> {
        using other_types = unique_types_impl<Other...>::type;
        using type = std::conditional_t<contains_type<T, Other...>(), other_types, types_cat_t<types<T>, other_types>>;
    };
 
    template <types_concept T, types_container Container> struct types_to_containers;
 
    template <typename... Types, types_container Container> struct types_to_containers<types<Types...>, Container> {
        using type = types<typename Container::template container<Types>...>;
    };
 
    template <types_concept T, types_transform Transform> struct types_transform_impl;
 
    template <typename... Types, types_transform Transform> struct types_transform_impl<types<Types...>, Transform> {
        using type = Transform::template transform<Types...>;
    };
 
    template <typename T, std::size_t N, std::size_t I, typename Type, typename... Other>
    constexpr std::size_t types_index_of_impl() {
        if constexpr (std::is_same_v<T, Type>) {
            if constexpr (N == 0) {
                return I;
            } else if constexpr (sizeof...(Other) != 0) {
                return types_index_of_impl<T, N - 1, I + 1, Other...>();
            }
        } else if constexpr (sizeof...(Other) != 0) {
            return types_index_of_impl<T, N, I + 1, Other...>();
        }
        assert(false);
    }
 
    template <typename T, types_concept Types, std::size_t N> struct types_index_of;
 
    template <typename T, typename... Types, std::size_t N> struct types_index_of<T, types<Types...>, N> {
        static constexpr std::size_t value = types_index_of_impl<T, N, 0, Types...>();
    };
 
    template <types_concept Types, std::size_t I> struct types_get_impl;
 
    template <typename... Types, std::size_t I>
        requires(sizeof...(Types) > 0)
    struct types_get_impl<types<Types...>, I> {
        using type = std::tuple_element_t<I, std::tuple<Types...>>;
    };
 
    template <std::size_t I> struct types_get_impl<types<>, I> {
        using type = void;
    };
 
    template <types_concept Types> struct types_unique_impl;
 
    template <typename... Types> struct types_unique_impl<types<Types...>> {
        using type = unique_types_impl<Types...>::type;
    };
 
    template <types_concept Types, typename Unique> struct types_to_arrays;
 
    template <typename... Types, typename... Unique> struct types_to_arrays<types<Types...>, types<Unique...>> {
        using type = types<std::array<Unique, types_count<types<Types...>>::template value<Unique>>...>;
    };
 
    template <typename Search, typename Type, typename... Other> struct types_remove_impl {
        using rest = types_remove_impl<Search, Other...>::type;
 
        using type = std::conditional_t<std::is_same_v<Type, Search>, rest, types_cat_t<types<Type>, rest>>;
    };
 
    template <typename Search, typename Type> struct types_remove_impl<Search, Type> {
        using type = std::conditional_t<std::is_same_v<Type, Search>, types<>, types<Type>>;
    };
 
    template <typename Types, typename Type> struct types_remove;
 
    template <typename... Types, typename Type>
        requires(sizeof...(Types) > 0)
    struct types_remove<types<Types...>, Type> {
        using type = types_remove_impl<Type, Types...>::type;
    };
 
    template <typename Type> struct types_remove<types<>, Type> {
        using type = types<>;
    };
 
    template <std::size_t N, types_concept Types> struct types_view;
 
    template <std::size_t N, typename Type, typename... Other> struct types_view<N, types<Type, Other...>> {
        using type = types_cat_t<
            types<Type>,
            std::conditional_t<(N > 1), typename types_view<N - 1, types<Other...>>::type, types<>>>;
    };
 
    template <std::size_t N> struct types_view<N, types<>> {
        using type = types<>;
    };
}
 
template <types_concept Types, std::size_t I> using types_get_t = detail::types_get_impl<Types, I>::type;
 
template <typename... Types> using unique_types_t = detail::unique_types_impl<Types...>::type;
 
template <types_concept Types> using types_unique_t = detail::types_unique_impl<Types>::type;
 
template <types_concept Types, types_transform Transform>
using types_transform_t = detail::types_transform_impl<Types, Transform>::type;
 
template <types_concept Types, types_container Container = types_containers::vector>
using types_to_containers_t = detail::types_to_containers<Types, Container>::type;
 
template <types_concept Types, typename T, std::size_t Skip = 0>
inline constexpr std::size_t types_index_of_v = detail::types_index_of<T, Types, Skip>::value;
 
template <types_concept Types> using types_to_arrays_t = detail::types_to_arrays<Types, types_unique_t<Types>>::type;
 
/*
 * @brief Alias for removing type from a types list
 *
 * @tparam Types The types list.
 * @tparam T The type to remove
 */
template <types_concept Types, typename T> using types_remove_t = detail::types_remove<Types, T>::type;
 
template <types_concept Types, std::size_t N> using types_view_t = detail::types_view<N, Types>::type;
 
}
 
#endif