typelist.cpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2026 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#include "samples_output.hpp"
#include "samples_types_printer.hpp"
 
#include <ugmisc/typelist.hpp>
 
#include <iostream>
#include <variant>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
 
 
using namespace ugmisc;
 
 
/*
 * Later, in main(), we will print the expected output of each function call
 * after the call itself, and that will be much easier and more legible if the
 * types are represented by known names that we can write directly.
 *
 * Compare
 *
 *     expect << typeid(Cat).name() << "\n";
 *
 * to
 *
 *     expect << "Cat\n";
 *
 * sTypeName will be found and returned by getTypeName<Type>().
 */
#define TYPE(name) \
    struct name { \
        static const char * const sTypeName; \
    }; \
    const char * const name::sTypeName = #name
 
TYPE(Lion);
TYPE(Siamese);
TYPE(Car);
TYPE(Van);
 
TYPE(Lions);
TYPE(Siameeses);
TYPE(Cars);
TYPE(Vans);
 
 
template<typename T>
struct PluraliseBase {
    static std::string sTypeName() {
        return std::string("Pluralise<") + getTypeName<T>() + ">";
    }
};
 
template<typename T>
struct Pluralise;
 
template<>
struct Pluralise<Lion> : public PluraliseBase<Lion> {
    using type = Lions;
};
 
template<>
struct Pluralise<Siamese> : public PluraliseBase<Siamese> {
    using type = Siameeses;
};
 
template<>
struct Pluralise<Car> : public PluraliseBase<Car> {
    using type = Cars;
};
 
template<>
struct Pluralise<Van> : public PluraliseBase<Van> {
    using type = Vans;
};
 
 
using Cats = type_list<Lion, Siamese>;
using Vehicles = type_list<Car, Van>;
using All = concatenate_type_lists_t<Cats, Vehicles>;
 
using CatsVariant = Cats::apply_t<std::variant>;
using VehiclesTuple = Vehicles::apply_t<std::tuple>;
 
using Plurals = type_list_apply_each<Pluralise, All>;
using Pluralisers = type_list_apply_each_class<Pluralise, All>;
 
 
template<class T>
struct is_cat : public std::false_type {};
 
template<>
struct is_cat<Lion> : public std::true_type {};
 
template<>
struct is_cat<Siamese> : public std::true_type {};
 
 
using CatsFromAll = type_list_filter<is_cat, All>;
using AllButCats = type_list_filter<is_cat, All, invert_test>;
using CatsFromVarious = flatten_filter<
    is_cat,
    no_invert_test,
    Lion,
    type_list<Car, Siamese>,
    Van
    >;
 
using Backward = type_list_stride<-1, -1, All::size, All>;
 
 
template<class T, class...Extras>
static void print(const char *name, Extras...extras) {
    SampleOutput out;
    TypesPrinter printer{out};
    /*
     * The name is explicitly passed in via the macro anyway, so there is no
     * point separately expecting it later.
     */
    out.always() << name << ":\n";
    printer.print<T>();
    [[maybe_unused]] auto& _out = (out << ... << extras);
}
 
#define PRINT_LAST(...) print<__VA_ARGS__>(#__VA_ARGS__)
#define PRINT(...) print<__VA_ARGS__>(#__VA_ARGS__, "\n")
 
int main(int, char**) {
    auto expect = SampleOutput().expect();
    auto always = SampleOutput().always();
 
    PRINT(Cats);
    expect << "type_list\n" "  Lion Siamese\n"
        "\n";
 
    PRINT(Vehicles);
    expect << "type_list\n" "  Car Van\n"
        "\n";
 
    PRINT(All);
    expect << "type_list\n" "  Lion Siamese Car Van\n"
        "\n";
 
    PRINT(CatsVariant);
    expect << "variant\n" "  Lion Siamese\n"
        "\n";
 
    PRINT(VehiclesTuple);
    expect << "tuple\n" "  Car Van\n"
        "\n";
 
    PRINT(CatsFromAll);
    expect << "type_list\n" "  Lion Siamese\n"
        "\n";
 
    PRINT(AllButCats);
    expect << "type_list\n" "  Car Van\n"
        "\n";
 
    PRINT(CatsFromVarious);
    expect << "type_list\n" "  Lion Siamese\n"
        "\n";
 
    PRINT(Plurals);
    expect << "type_list\n" "  Lions Siameeses Cars Vans\n"
        "\n";
 
    PRINT(Pluralisers);
    expect << "type_list\n"
        "  Pluralise<Lion> Pluralise<Siamese> Pluralise<Car> Pluralise<Van>\n"
        "\n";
 
    PRINT(Backward);
    expect << "type_list\n"
        "  Van Car Siamese Lion\n"
        "\n";
 
    PRINT(All::stride_t<0, 2, 2>);
    expect << "type_list\n"
        "  Lion Car\n"
        "\n";
 
    always << "\nResults of using the type_list methods and operators:\n\n";
 
    type_list<Lion>    lion;
    type_list<Siamese> siamese;
 
    PRINT( decltype(lion.append(siamese)) );
    expect << "type_list\n"
        "  Lion Siamese\n"
        "\n";
 
    PRINT( decltype(lion + siamese) );
    expect << "type_list\n"
        "  Lion Siamese\n"
        "\n";
 
    // Stride can be represented by an integer_sequence.
    // Base 0, stride 2, count 2.
    std::integer_sequence<int, 0, 2, 2> stride_args;
 
    // Stride can be represented by integral_constants.
    std::integral_constant<int, 0> base;
    std::integral_constant<int, 2> stride;
    std::integral_constant<int, 2> count;
 
    All all;
 
    PRINT( decltype(all.stride(stride_args)) );
    expect << "type_list\n"
        "  Lion Car\n"
        "\n";
 
    PRINT_LAST( decltype(all.stride(base, stride, count)) );
    expect << "type_list\n"
        "  Lion Car\n";
 
    return 0;
}