PrintType.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_PRINTING_TYPE_PRINT_TYPE_HPP
#define MIMICPP_PRINTING_TYPE_PRINT_TYPE_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/printing/Format.hpp"
#include "mimic++/printing/Fwd.hpp"
#include "mimic++/utilities/PriorityTag.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <functional>
    #include <iterator>
    #include <type_traits>
    #include <typeinfo>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::printing::type
{
    template <typename T>
    [[nodiscard]]
    StringT type_name();

    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_type(OutIter out, StringT name);

    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_function(OutIter out, StringT name);
}
 
#ifdef MIMICPP_CONFIG_EXPERIMENTAL_PRETTY_TYPES
 
    #if MIMICPP_DETAIL_IS_GCC || MIMICPP_DETAIL_IS_CLANG
 
        #ifndef MIMICPP_DETAIL_IS_MODULE
            #include <cstdlib>
            #include <cxxabi.h>
            #include <memory>
        #endif
 
namespace mimicpp::printing::type
{
    namespace detail
    {
        struct free_deleter
        {
            void operator()(char* const c) const noexcept
            {
                std::free(c);
            }
        };
    }
 
    template <typename T>
    StringT type_name()
    {
        auto* const rawName = typeid(T).name();
 
        // see: https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_demangling.html
        int status{};
        std::unique_ptr<char, detail::free_deleter> const demangledName{
            abi::__cxa_demangle(rawName, nullptr, nullptr, &status)};
        if (0 == status)
        {
            return {demangledName.get()};
        }
 
        return {rawName};
    }
}
 
    #else
 
namespace mimicpp::printing::type
{
    template <typename T>
    StringT type_name()
    {
        return typeid(T).name();
    }
}
 
    #endif
 
    #include "mimic++/printing/type/NameParser.hpp"
    #include "mimic++/printing/type/NamePrintVisitor.hpp"
 
namespace mimicpp::printing::type
{
    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_type(OutIter out, StringT name)
    {
        static_assert(parsing::parser_visitor<PrintVisitor<OutIter>>);
 
        PrintVisitor visitor{std::move(out)};
        parsing::NameParser parser{std::ref(visitor), name};
        parser.parse_type();
 
        return visitor.out();
    }
 
    namespace detail
    {
        [[nodiscard]]
        MIMICPP_DETAIL_CONSTEXPR_STRING StringT remove_template_details(StringT name)
        {
            if (name.ends_with(']'))
            {
                auto rest = name | std::views::reverse | std::views::drop(1);
                if (auto const closingIter = util::find_closing_token(rest, ']', '[');
                    closingIter != rest.end())
                {
                    auto const end = std::ranges::find_if_not(
                        closingIter + 1,
                        rest.end(),
                        lexing::is_space);
                    name.erase(end.base(), name.end());
                }
            }
 
            return name;
        }
    }
 
    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_function(OutIter out, StringT name)
    {
        name = detail::remove_template_details(std::move(name));
 
        static_assert(parsing::parser_visitor<PrintVisitor<OutIter>>);
 
        PrintVisitor visitor{std::move(out)};
        parsing::NameParser parser{std::ref(visitor), name};
        parser.parse_function();
 
        return visitor.out();
    }
}
 
#else
 
namespace mimicpp::printing::type
{
    template <typename T>
    StringT type_name()
    {
        return typeid(T).name();
    }
 
    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_type(OutIter out, StringT name)
    {
        return std::ranges::copy(name, std::move(out)).out;
    }
 
    template <print_iterator OutIter>
    MIMICPP_DETAIL_CONSTEXPR_STRING OutIter prettify_function(OutIter out, StringT name)
    {
        return std::ranges::copy(name, std::move(out)).out;
    }
}
 
#endif
 
namespace mimicpp::printing::type::detail
{
    template <typename Printer, typename T, typename OutIter>
    concept type_printer_for = print_iterator<OutIter>
                            && requires(OutIter out) {
                                   typename Printer;
                                   { Printer::print(out) } -> std::convertible_to<OutIter>;
                               };
 
    template <typename T, print_iterator OutIter, type_printer_for<T, OutIter> Printer = mimicpp::custom::TypePrinter<T>>
    constexpr OutIter print_type_to([[maybe_unused]] util::priority_tag<4u> const, OutIter out)
    {
        return Printer::print(std::move(out));
    }
 
    template <typename T, print_iterator OutIter, type_printer_for<T, OutIter> Printer = common_type_printer<T>>
    constexpr OutIter print_type_to([[maybe_unused]] util::priority_tag<3u> const, OutIter out)
    {
        return Printer::print(std::move(out));
    }
 
    template <typename T, print_iterator OutIter, type_printer_for<T, OutIter> Printer = signature_type_printer<T>>
    constexpr OutIter print_type_to([[maybe_unused]] util::priority_tag<2u> const, OutIter out)
    {
        return Printer::print(std::move(out));
    }
 
    template <typename T, print_iterator OutIter, type_printer_for<T, OutIter> Printer = template_type_printer<T>>
    constexpr OutIter print_type_to([[maybe_unused]] util::priority_tag<1u> const, OutIter out)
    {
        return Printer::print(std::move(out));
    }
 
    template <typename T, print_iterator OutIter>
    OutIter print_type_to([[maybe_unused]] util::priority_tag<0u> const, OutIter out)
    {
        return type::prettify_type(
            std::move(out),
            type::type_name<T>());
    }
 
    inline constexpr util::priority_tag<4u> maxPrintTypePriority{};
 
    template <typename T>
    struct print_type_helper
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return print_type_to<T>(maxPrintTypePriority, std::move(out));
        }
    };
 
    template <typename T>
        requires(!std::is_array_v<T>)
    struct print_type_helper<volatile T>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                " volatile");
        }
    };
 
    template <typename T>
        requires(!std::is_array_v<T>)
    struct print_type_helper<const T>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                " const");
        }
    };
 
    template <typename T>
        requires(!std::is_array_v<T>)
    struct print_type_helper<const volatile T>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                " const volatile");
        }
    };
 
    template <typename T>
    struct print_type_helper<T&>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                "&");
        }
    };
 
    template <typename T>
    struct print_type_helper<T&&>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                "&&");
        }
    };
 
    template <typename T>
    struct print_type_helper<T*>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                "*");
        }
    };
 
    template <typename T>
    struct print_type_helper<T[]>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                "[]");
        }
    };
 
    template <typename T, std::size_t n>
    struct print_type_helper<T[n]>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T>{}(std::move(out)),
                "[{}]",
                n);
        }
    };
 
    // multidimensional arrays are evaluated from left to right,
    // but we need it from right to left.
    template <typename T, std::size_t n, std::size_t m>
    struct print_type_helper<T[n][m]>
    {
        template <print_iterator OutIter>
        [[nodiscard]]
        constexpr OutIter operator()(OutIter out) const
        {
            return format::format_to(
                print_type_helper<T[n]>{}(std::move(out)),
                "[{}]",
                m);
        }
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::printing
{
    template <typename T>
    class PrintTypeFn
    {
    public:
        template <print_iterator OutIter>
        constexpr OutIter operator()(OutIter out) const
        {
            return type::detail::print_type_helper<T>{}(std::move(out));
        }
 
        [[nodiscard]]
        StringT operator()() const
        {
            StringStreamT stream{};
            std::invoke(*this, std::ostreambuf_iterator{stream});
            return std::move(stream).str();
        }
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{

    template <typename T>
    [[maybe_unused]] inline constexpr printing::PrintTypeFn<T> print_type{};

}
 
#endif