samples_types_printer.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: © 2026 Larry Chips <larry@larrychips.net>
 * SPDX-Licence-Identifier: MIT
 */
#ifndef UGMISC_SAMPLES_TYPES_PRINTER_HPP
#define UGMISC_SAMPLES_TYPES_PRINTER_HPP
 
#include <ugmisc/member.hpp>
#include <ugmisc/typelist.hpp>
#include <variant>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <utility>
 

namespace _samples {
 
UGMISC_DECL_MEMBER_ACCESS(TypeNameAccess, sTypeName);
 
 
} /* ::_samples */
 
 
 

template<typename T>
auto getTypeName() {
    using Access = _samples::TypeNameAccess;
    ugmisc::static_member_value<Access, T> value_get;
 
    return ugmisc::static_member_caller<Access, T>::fallback([&]() {
        // If we are here, Calling sTypeName() failed.
        // So we try to get the value of sTypeName.
        // And finally fall back to typeid(U).name().
        return value_get.get([]() {
                return typeid(T).name();
                });
            })();
}
 
 
 

template<class OStream>
class TypesPrinter {
    OStream& oStream;
 
    template<class T>
    struct Types;
 
    template<class, template<class...> class Tmp>
    struct Template;
 
    template<template<class...> class Tmp, class...T>
    class Types<Tmp<T...>> {
        using Type = Tmp<T...>;
 
        template<class U>
        static void printOneType(OStream& os) {
            if constexpr ( std::is_const_v<U> ) {
                os << " const ";
            } else {
                os << " ";
            }
            auto name = getTypeName<U>();
            os << name;
            if constexpr ( std::is_lvalue_reference_v<U> ) {
                os << "&";
            } else if constexpr ( std::is_rvalue_reference_v<U> ) {
                os << "&&";
            }
        }
 
    public:
        static void print(OStream& os) {
            Template<void, Tmp>::print(os);
            constexpr auto n = sizeof...(T);
 
            if constexpr ( n == 0 ) {
                os << "  <no types>\n";
            } else {
                os << " ";
                (... , printOneType<T>(os));
                os << "\n";
            }
        }
    };
 
    template<class V>
    struct Template<V, std::variant> {
        static void print(OStream& os) { os << "variant\n"; }
    };
 
    template<class V>
    struct Template<V, std::tuple> {
        static void print(OStream& os) { os << "tuple\n"; }
    };
 
    template<class V>
    struct Template<V, ugmisc::type_list> {
        static void print(OStream& os) { os << "type_list\n"; }
    };
 
    template<class, template<class...> class>
    struct Template {
        static void print(OStream& os) { os << "other\n"; }
    };
 
public:
    TypesPrinter(OStream& os) : oStream(os) {}
    TypesPrinter(const TypesPrinter&) = default;
    TypesPrinter(TypesPrinter&&) = default;
 
    template<class T>
    const TypesPrinter& print() const {
        using PlainT = std::remove_cv_t<std::remove_reference_t<T>>;
        Types<PlainT>::print(oStream);
        return *this;
    }
 
    template<class T>
    const TypesPrinter& print(T&&) const {
        return print<T>();
    }
 
    template<class T>
    const TypesPrinter& operator()() const {
        return print<T>();
    }
};
 
template<class OStream>
TypesPrinter(OStream&) -> TypesPrinter<OStream>;
 
#endif /* UGMISC_SAMPLES_TYPES_PRINTER_HPP */