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 imp_ {
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...>;
};
} /* imp_ */
 
 
 
 
template<> struct type_list<> : public imp_::type_list_common<> {
};
 
 
template<class T1, class...Ts> struct type_list<T1, Ts...>
: public imp_::type_list_common<T1, Ts...>
{
private:
    template<class, std::size_t I> struct get_indexed_type {
        using type = typename type_list<Ts...>::indexed_type<I - 1>;
    };
 
    template<class T> struct get_indexed_type<T, 0> {
        using type = T1;
    };
 
public:
    template<std::size_t I> using indexed_type = typename get_indexed_type<void, I>::type;
};
 
 
 
template<std::size_t I, class T> struct get_indexed {};
 
template<std::size_t I, class...T> struct get_indexed<I, type_list<T...>> {
    using type = typename type_list<T...>::template indexed_type<I>;
};
 
template<std::size_t I, class T> using get_indexed_t = typename get_indexed<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<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;
 
 
} /* ::ugmisc */