typelist.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2025 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#ifndef UGMISC_TYPELIST_HPP
#define UGMISC_TYPELIST_HPP
 
#include <cstddef>
#include <type_traits>
#include <utility>
 

 
 
 
 
namespace ugmisc {
 

enum test_modifier {
    no_invert_test, 
    invert_test     
};
 
 
/* *****************************************************************************
 *
 * ugmisc::typelist_ namespace contains implementation details
 *
 *
 * Forward declarations in ugmisc namespace are first.
 *
 * Then forward declarations in ugmisc::typelist_ namespace.
 *
 * Then template type alias declarations in ugmisc follow.
 *
 * Then class template definitions.
 *
 *
 * Using this order allows classes like instances of type_list to have methods
 * which use the template type aliases.  The methods can then be used for
 * convenience by the user.
 *
 * ****************************************************************************/
 
// Forwards in ugmisc.
template<class...>                        struct concatenate_type_lists;
template<class...>                        struct flatten;
template<class T>                         struct get_as_list;
template<std::size_t, std::size_t, class> struct get_type_list_sublist;
template<class>                           struct is_type_list;
template<class...>                        struct type_list;
template<class>                           struct unwrap;
template<class>                           struct wrapped_list;
 
// Forwards in ugmisc::typelist_.
namespace typelist_ {
template<template<class> class, class> struct apply_each;
template<template<class> class, class, test_modifier>
                                       struct filter_type_list;
template<std::size_t, class>           struct get_type_list_member;
template<std::ptrdiff_t, std::ptrdiff_t, std::size_t, class>
                                       struct type_list_stride;
} /* typelist_ (ugmisc::typelist_) */
 

template<class...T>
using concatenate_type_lists_t = typename concatenate_type_lists<T...>::type;
 

template<class T> using get_as_list_t = typename get_as_list<T>::type;
 
 
template<class T> static constexpr bool is_type_list_v = is_type_list<T>::value;
 
 
template<class...T> static constexpr bool are_type_lists_v = (... && is_type_list_v<T>);
 
 
 

template<std::size_t I, class T> using type_list_member =
    typename typelist_::get_type_list_member<I, T>::type;
 
 
 

template<class...T> using flatten_t = typename flatten<T...>::type;
 
 
 

template<std::size_t From, std::size_t To, class T>
using type_list_sublist = typename get_type_list_sublist<From, To, T>::type;

template<std::size_t From, std::size_t Count, class T>
using type_list_sized_sublist = type_list_sublist<From, From + Count, T>;

template<std::size_t Count, class T>
using type_list_prefix = type_list_sublist<0, Count, T>;

template<std::size_t Count, class T>
using type_list_suffix = type_list_sublist<T::size - Count, T::size, T>;

template<std::size_t Count, class T>
using type_list_remove_prefix = type_list_sublist<Count, T::size, T>;

template<std::size_t Count, class T>
using type_list_remove_suffix = type_list_sublist<0, T::size-Count, T>;
 

template<std::size_t From, std::size_t To, class...T>
using flatten_sublist = type_list_sublist<From, To, flatten_t<T...>>;

template<std::size_t From, std::size_t Count, class...T>
using flatten_sized_sublist = type_list_sized_sublist<From, Count, flatten_t<T...>>;

template<std::size_t Count, class...T>
using flatten_prefix = type_list_prefix<Count, flatten_t<T...>>;

template<std::size_t Count, class...T>
using flatten_suffix = type_list_suffix<Count, flatten_t<T...>>;

template<std::size_t Count, class...T>
using flatten_remove_prefix = type_list_remove_prefix<Count, flatten_t<T...>>;

template<std::size_t Count, class...T>
using flatten_remove_suffix = type_list_remove_suffix<Count, flatten_t<T...>>;
 
 
 

template<
    template<class> class Test,
    class T,
    test_modifier Mod = no_invert_test
    >
using type_list_filter =
    typename typelist_::filter_type_list<Test, T, Mod>::type;
 

template<
    template<class> class Test,
    class T,
    test_modifier Mod = static_cast<test_modifier>(0)
    >
using filter_type_list = type_list_filter<Test, T, Mod>;
 
 
 

template< template<class> class F, class T >
using type_list_apply_each_class = typename typelist_::apply_each<F, T>::class_types;
 

template< template<class> class F, class T >
using type_list_apply_each = typename typelist_::apply_each<F, T>::inner_types;
 

template< template<class> class F, class...T >
using flatten_apply_each_class = type_list_apply_each_class<F, flatten_t<T...>>;
 

template< template<class> class F, class...T >
using flatten_apply_each = type_list_apply_each<F, flatten_t<T...>>;
 

template<
    template<class> class Test,
    test_modifier Mod,
    class...T
    >
using flatten_filter = type_list_filter<Test, flatten_t<T...>, Mod>;
 
 
 

template<
    std::ptrdiff_t Base,
    std::ptrdiff_t Stride,
    std::size_t    Count,
    class          T
    >
using type_list_stride =
    typename typelist_::type_list_stride<Base, Stride, Count, T>::type;
 

template<
    std::ptrdiff_t Base,
    std::ptrdiff_t Stride,
    std::size_t    Count,
    class...T
    >
using flatten_stride = type_list_stride<Base, Stride, Count, flatten_t<T...>>;
 
 

namespace typelist_ {
 
template<std::size_t I, class T> struct get_type_list_member {};
 
template<std::size_t I, class T1, class...T>
struct get_type_list_member<I, type_list<T1, T...>> {
    static_assert( I < sizeof...(T) + 1, "Index out of range" );
    using type = typename get_type_list_member<I-1, type_list<T...>>::type;
};
 
template<class T1, class...T> struct get_type_list_member<0, type_list<T1, T...>> {
    using type = T1;
};
 
 
 
 
template<template <class> class Test, class T, test_modifier Mod>
struct filter_type_list {
};
 
 
template<template<class> class Test, test_modifier Mod>
struct filter_type_list<Test, type_list<>, Mod> {
    using type = type_list<>;
};
 
 
template<template <class> class Test, class T, test_modifier Mod>
struct filter_type_list<Test, type_list<T>, Mod> {
    using type = std::conditional_t<
        Test<T>::value != (Mod == invert_test),
        type_list<T>,
        type_list<>
        >;
};
 
 
template<template<class> class Test, test_modifier Mod, class T1, class T2, class...Ts>
struct filter_type_list<Test, type_list<T1, T2, Ts...>, Mod> {
private:
    using all = type_list<T1, T2, Ts...>;
    static constexpr std::size_t halfway = all::size / 2;
    using first_half = type_list_prefix<halfway, all>;
    using second_half = type_list_remove_prefix<halfway, all>;
 
public:
    using type = concatenate_type_lists_t<
        typename filter_type_list<Test, first_half, Mod>::type,
        typename filter_type_list<Test, second_half, Mod>::type
        >;
};
 
 
template< template<class> class F, class...T >
struct apply_each<F, type_list<T...>> {
    using class_types = type_list<F<T>...>;
    using inner_types = type_list<typename F<T>::type...>;
};
 
 
 
 
/*
 * Used by type_list_stride specialisations.  Instantiating one of these
 * asserts that the stride array doesn't go out of the bounds of the underlying
 * array.
 */
template<
    std::ptrdiff_t SignedBase,
    std::ptrdiff_t Stride,
    std::size_t    Count,
    class          T
    >
struct type_list_stride_params {
 
    static_assert( is_type_list_v< T > );
 
    static constexpr std::size_t Base =
        (std::size_t)(SignedBase >= 0 ? SignedBase : T::size + SignedBase);
 
 
    template<std::size_t new_index, bool check = true>
    static constexpr std::size_t original_index() {
        static_assert( (!check) || new_index < Count );
        const std::ptrdiff_t base = Base;
        return base + ((std::ptrdiff_t)new_index) * Stride;
    }
 
 
    template<std::size_t original_index, bool check = true>
    static constexpr std::size_t new_index() {
        /*
         * original_index Io
         * new_index      In
         * base           B
         * stride         S
         *
         * Io = B + In*S
         * In = (Io - B)/S
         */
 
        constexpr std::ptrdiff_t dist = ((std::ptrdiff_t)original_index) - Base;
        constexpr std::ptrdiff_t new_index_signed = dist/Stride;
        constexpr std::ptrdiff_t new_index_mod = dist%Stride;
        constexpr std::size_t    new_index = (std::size_t)new_index_signed;
 
        static_assert(
                (!check) || (new_index >= T::size),
                "Index out of underlying array bounds."
                );
 
        static_assert(
                (!check) || (original_index >= Count),
                "Index out of stride array bounds."
                );
 
        static_assert(
                (!check) || (new_index_mod == 0),
                "Index not touched by the stride array."
                );
 
        return new_index;
    }
 
 
    // original_index() returns an unsigned index, so we don't need a lower
    // bound check here.
    static_assert(
            Count == 0 || original_index<Count - 1, false>() < T::size,
            "type_list_stride out of bounds."
            );
};
 
 
 
 
template<
    std::ptrdiff_t Base,
    std::ptrdiff_t Stride,
    std::size_t    Count,
    class          T
    >
struct type_list_stride {
private:
    using params = type_list_stride_params<Base, Stride, Count, T>;
 
    template<class S> struct deduce_type;
 
    template<std::size_t...N> struct deduce_type<std::index_sequence<N...>> {
        using type = ::ugmisc::type_list<
            type_list_member< params::template original_index<N>(), T >...
            >;
    };
 
public:
    using type = typename deduce_type< std::make_index_sequence<Count> >::type;
};
 
 
 
} // ugmisc::typelist_
 
 
 
 
template<class T> struct is_type_list : public std::false_type {};
 
template<class...T> struct is_type_list<type_list<T...>> : std::true_type {};
 
 
 
 
template<> struct concatenate_type_lists<> {
    using type = type_list<>;
};
 
 
template<class...T> struct concatenate_type_lists<type_list<T...>> {
    using type = type_list<T...>;
};
 
 
template<class T1, class T2, class T3, class...Ts> struct concatenate_type_lists<T1, T2, T3, Ts...> {
    static_assert( are_type_lists_v<T1, T2, T3, Ts...>  );
    using type = typename concatenate_type_lists<
        typename concatenate_type_lists<T1, T2>::type,
        typename concatenate_type_lists<T3, Ts...>::type
        >::type;
};
 
 
template<class T, class...Ts>
struct concatenate_type_lists< T, type_list<Ts...> >
{
    static_assert( is_type_list_v<T> );
    using type = typename T::template append<Ts...>;
};
 
 
 
 
/*
 * TODO: Reimplement sublists as a special case of strides.
 */
template<std::size_t From, class...T>
struct get_type_list_sublist<From, From, type_list<T...>> {
    static_assert( From <= sizeof...(T) );
    using type = type_list<>;
};
 
template<std::size_t From, class...T>
struct get_type_list_sublist<From, From+1, type_list<T...>> {
    static_assert( From < sizeof...(T) );
    using type =
        type_list< type_list_member<From, type_list<T...>> >;
};
 
template<std::size_t From, std::size_t To, class...T>
struct get_type_list_sublist<From, To, type_list<T...>> {
private:
    static_assert( To >= From, "Invalid range: To must be no less than From." );
    static_assert( To > From+1, "Logic error. Wrong partial specialisation." );
 
    using list = type_list<T...>;
 
    static constexpr std::size_t from1 = From;
    static constexpr std::size_t to1 = From + (To - From)/2;
    static constexpr std::size_t from2 = to1;
    static constexpr std::size_t to2 = To;
 
    using part1 = typename get_type_list_sublist<from1, to1, list>::type;
    using part2 = typename get_type_list_sublist<from2, to2, list>::type;
 
public:
    using type = concatenate_type_lists_t< part1, part2 >;
};
 
 
/*
 * This is deprecated.
 * Use get_type_list_sublist instead.
 */
template<std::size_t From, std::size_t To, class T>
struct get_type_list_slice : public get_type_list_sublist<From, To, T> {};
 
 
 

template<class T> struct wrapped_list {
    static_assert(
            false,
            "wrapped_list must wrap a wrapped_list or a type_list"
            );
};
 
 
template<class...T> struct wrapped_list<type_list<T...>> {
    using type = type_list<T...>;
};
 
 
template<class T> struct wrapped_list<wrapped_list<T>> {
    using type = wrapped_list<T>;
};
 
 
 
 
template<class T> struct get_as_list {
    using type = type_list<T>;
};
 
 
template<class...T> struct get_as_list<type_list<T...>> {
    using type = type_list<T...>;
};
 
 
// This has never been used or documented.
template<class T> struct unwrap {
    using type = T;
};
 
 
template<class T> struct unwrap<wrapped_list<T>> {
    using type = T;
};
 
 
template<class...T> struct flatten {
    // Every flatten special defs a type_list type.  The generic one
    // concatenates the lists created from each tparam.
    using type = concatenate_type_lists_t<typename flatten<T>::type...>;
};
 
 
/*
 * A single type which is not a type_list or wrapped_list is simply put into a
 * type_list.
 */
template<class T> struct flatten<T> {
    using type = type_list<T>;
};
 
 
/*
 * A type list needs unwrapping recursively, so we flatten each of the member
 * types.
 */
template<class...T> struct flatten< type_list<T...> > {
    using type = concatenate_type_lists_t<typename flatten<T>::type...>;
};
 
 
/*
 * A wrapped_list is unwrapped once, then the content put into a list.
 */
template<class T> struct flatten< wrapped_list<T> > {
    using type = type_list<T>; // Note the lack of recursion here.
};
 
 
 

template<class...T> struct type_list {
    static constexpr std::size_t size = sizeof...(T);

    template<template<class...> class Templ> using apply_t = Templ<T...>;

    template<template<class...> class Templ> using apply = apply_t<Templ>;

    template<template<class...> class Templ> using call_t =
        typename Templ<T...>::type;

    template<template<class...> class Templ> using call = call_t<Templ>;

    template<class...U>
    using prepend_t = type_list<U..., T...>;

    template<class...U> using prepend = prepend_t<U...>;

    template<class...U>
    using append_t = type_list<T..., U...>;

    template<class...U> using append = append_t<U...>;

    template<std::size_t From, std::size_t To>
    using sublist_t = type_list_sublist<From, To, type_list>;

    template<
        std::ptrdiff_t Base,
        std::ptrdiff_t Stride,
        std::size_t    Count
        >
    using stride_t = type_list_stride<Base, Stride, Count, type_list>;

    template<
        std::ptrdiff_t Base,
        std::ptrdiff_t Stride,
        std::size_t    Count
        >
    using stride = stride_t<Base, Stride, Count>;
};
 
 
 

template<class T, class U>
constexpr auto operator + (T, U) -> concatenate_type_lists_t<T, U> {
    return {};
}
 
 
} /* ::ugmisc */
 
#endif /* UGMISC_TYPELIST_HPP */