typelist.hpp

Go to the documentation of this file.

/*
 * SPDX-Licence-Identifier: MIT
 *
 * Copyright 2025 Larry Chips
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the “Software”), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#pragma once
 
#include <type_traits>
 

 
 
 
 
namespace ugmisc {
 

template<class...T> struct type_list;
 
 
 
 
namespace typelist_ {
 
 
template<class...T> struct type_list_common {
    static constexpr std::size_t size = sizeof...(T);
 
    template<template<class...> class Templ> using apply = Templ<T...>;
 
    template<class...U>
    using prepend = type_list<U..., T...>;
 
    template<class...U>
    using append = type_list<T..., U...>;
};
 
 
} /* typelist_ */
 
 
 
 
template<> struct type_list<> : public typelist_::type_list_common<> {
};
 
 
template<class T1, class...Ts> struct type_list<T1, Ts...>
: public typelist_::type_list_common<T1, Ts...>
{
};
 
 
 
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<std::size_t I, class T> using type_list_member =
    typename get_type_list_member<I, T>::type;
 
 
 
 
 
 
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<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<class...> struct concatenate_type_lists;
 
 
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...>;
};
 

template<class...T>
using concatenate_type_lists_t = typename concatenate_type_lists<T...>::type;
 
 
 
 
template<std::size_t From, std::size_t To, class T> struct get_type_list_slice;
 
template<std::size_t From, class...T>
struct get_type_list_slice<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_slice<From, From+1, type_list<T...>> {
    static_assert( From < sizeof...(T) );
    using type =
        type_list< typename get_type_list_member<From, type_list<T...>>::type >;
};
 
template<std::size_t From, std::size_t To, class...T>
struct get_type_list_slice<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_slice<from1, to1, list>::type;
    using part2 = typename get_type_list_slice<from2, to2, list>::type;
 
public:
    using type = concatenate_type_lists_t< part1, part2 >;
};
 
 
 

template<class T> struct wrapped_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...>;
};
 
 
template<class T> using get_as_list_t = typename get_as_list<T>::type;
 
 
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> using flatten_t = typename flatten<T...>::type;
 
 
 

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

template<std::size_t From, std::size_t Count, class T>
using type_list_sized_slice = type_list_slice<From, From + Count, T>;

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

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

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

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

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

template<std::size_t From, std::size_t Count, class...T>
using flatten_sized_slice = type_list_sized_slice<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...>>;
 
} /* ::ugmisc */