PrintType.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024-2026.
// 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"
#include "mimic++/utilities/SourceLocation.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <functional>
    #include <iterator>
    #include <type_traits>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::printing::type
{
    namespace detail
    {
        template <typename T>
        [[nodiscard]]
        consteval std::string_view raw_type_name() noexcept
        {
            return util::SourceLocation{}.function_name();
        }
 
        // GCOVR_EXCL_START
        inline constexpr auto typeNameConfig = std::invoke([] {
            auto const rawName = raw_type_name<int>();
            std::string_view const intName{"int"};
            std::size_t const prefix = rawName.rfind(intName);
            MIMICPP_ASSERT(prefix != std::string_view::npos, "Did not find `int` in the type-name string.");
 
            struct type_name_config
            {
                std::size_t prefix{};
                std::size_t suffix{};
            };
 
            return type_name_config{
                .prefix = prefix,
                .suffix = rawName.size() - intName.size() - prefix};
        });
        // GCOVR_EXCL_STOP
    }

    template <typename T>
    [[nodiscard]]
    consteval std::string_view type_name() noexcept
    {
        auto typeName = detail::raw_type_name<T>();
        typeName.remove_prefix(detail::typeNameConfig.prefix);
        typeName.remove_suffix(detail::typeNameConfig.suffix);
 
        return typeName;
    }

    template <print_iterator OutIter>
    constexpr OutIter prettify_type(OutIter out, std::string_view name);

    template <print_iterator OutIter>
    constexpr OutIter prettify_function(OutIter out, std::string_view name);
}
 
#ifdef MIMICPP_CONFIG_EXPERIMENTAL_PRETTY_TYPES
 
    #include "mimic++/printing/type/Parser.hpp"
    #include "mimic++/printing/type/PrintVisitor.hpp"
 
namespace mimicpp::printing::type
{
    template <print_iterator OutIter>
    constexpr OutIter prettify_type(OutIter out, std::string_view const name)
    {
        if (std::optional const typeId = parse_type(name))
        {
            parsing::PrintVisitor<OutIter> visitor{std::move(out)};
            visitor.visit(*typeId);
 
            return visitor.out();
        }
 
        return format::format_to(std::move(out), "{}", name);
    }
 
    template <print_iterator OutIter>
    constexpr OutIter prettify_function(OutIter out, std::string_view const name)
    {
        if (std::optional const functionId = parse_function(name))
        {
            parsing::PrintVisitor<OutIter> visitor{std::move(out)};
            visitor.visit(*functionId);
 
            return visitor.out();
        }
 
        return format::format_to(std::move(out), "{}", name);
    }
}
 
#else
 
namespace mimicpp::printing::type
{
    template <print_iterator OutIter>
    constexpr OutIter prettify_type(OutIter out, std::string_view const name)
    {
        return std::ranges::copy(name, std::move(out)).out;
    }
 
    template <print_iterator OutIter>
    constexpr OutIter prettify_function(OutIter out, std::string_view const 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