Printer.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // 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_PRINTER_HPP
#define MIMICPP_PRINTER_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/String.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/Utility.hpp"
 
#include <cstdint>
#include <functional>
#include <iterator>
#include <optional>
#include <ranges>
#include <source_location>
#include <sstream>
#include <string>
#include <string_view>
#include <utility>
 
#ifndef MIMICPP_CONFIG_USE_FMT
    #include <format>
#else
 
#if __has_include(<fmt/format.h>)
#include <fmt/format.h>
#else
        #error "The fmt formatting backend is explicitly enabled, but the include <fmt/format.h> can not be found."
#endif
 
#endif
 
namespace mimicpp
{
    using StringStreamT = std::basic_ostringstream<CharT, CharTraitsT>;
 
    template <typename T>
    concept print_iterator = std::output_iterator<T, const CharT&>;
 
    template <typename Printer, typename OutIter, typename T>
    concept printer_for = print_iterator<OutIter>
                        && requires(OutIter out)
                        {
                            {
                                Printer::print(out, std::declval<T&&>())
                            } -> std::convertible_to<OutIter>;
                        };
}
 
namespace mimicpp::format
{
#ifndef MIMICPP_CONFIG_USE_FMT
 
    // use std format
#ifndef _LIBCPP_VERSION
 
    using std::formatter;
    using std::format;
    using std::format_to;
    using std::vformat;
    using std::vformat_to;
    using std::make_format_args;
 
#else
 
    // libc++ has some serious trouble when using its std::format implementation.
    // Let's simply redirect any calls to std::vformat instead.
 
    using std::formatter;
    using std::vformat;
    using std::vformat_to;
    using std::make_format_args;
 
    template <typename... Args>
    [[nodiscard]]
    StringT format(const StringViewT fmt, Args&&... args)  // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        return format::vformat(
            fmt,
            std::make_format_args(args...));
    }
 
    template <class OutputIt, typename... Args>
    OutputIt format_to(const OutputIt out, const StringViewT fmt, Args&&... args)  // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        return format::vformat_to(
            std::move(out),
            fmt,
            std::make_format_args(args...));
    }
 
#endif
 
    namespace detail
    {
        template <typename Char>
        struct format_context;
 
        template <typename Char>
        using format_context_t = typename format_context<Char>::type;
 
        template <>
        struct format_context<char>
        {
            using type = std::format_context;
        };
 
        template <>
        struct format_context<wchar_t>
        {
            using type = std::wformat_context;
        };
 
        template <class T, class Char>
        concept formattable =
            std::semiregular<std::formatter<std::remove_cvref_t<T>, Char>>
            && requires(
            std::formatter<std::remove_cvref_t<T>, Char> formatter,
            T t,
            format_context_t<Char> formatContext,
            std::basic_format_parse_context<Char> parseContext
        )
            {
                { formatter.parse(parseContext) } -> std::same_as<typename std::basic_format_parse_context<Char>::iterator>;
                {
                    std::as_const(formatter).format(t, formatContext)
                } -> std::same_as<typename std::remove_reference_t<decltype(formatContext)>::iterator>;
            };
    }
 
    // use fmt format
#else
 
    using fmt::formatter;
    using fmt::format;
    using fmt::format_to;
    using fmt::vformat;
    using fmt::vformat_to;
    using fmt::make_format_args;
 
    namespace detail
    {
        template <class T, class Char>
        concept formattable = fmt::is_formattable<std::remove_reference_t<T>, Char>::value;
    }
 
#endif
}
 
template <>
struct mimicpp::format::formatter<mimicpp::ValueCategory, mimicpp::CharT>
    : public formatter<std::string_view, mimicpp::CharT>
{
    using ValueCategoryT = mimicpp::ValueCategory;
 
    auto format(
        const ValueCategoryT category,
        auto& ctx
    ) const
    {
        constexpr auto toString = [](const ValueCategoryT cat)
        {
            switch (cat)
            {
            case ValueCategoryT::lvalue: return "lvalue";
            case ValueCategoryT::rvalue: return "rvalue";
            case ValueCategoryT::any: return "any";
            }
 
            throw std::invalid_argument{"Unknown category value."};
        };
 
        return formatter<std::string_view, mimicpp::CharT>::format(
            toString(category),
            ctx);
    }
};
 
template <>
struct mimicpp::format::formatter<mimicpp::Constness, mimicpp::CharT>
    : public formatter<std::string_view, mimicpp::CharT>
{
    using ConstnessT = mimicpp::Constness;
 
    auto format(
        const ConstnessT category,
        auto& ctx
    ) const
    {
        constexpr auto toString = [](const ConstnessT value)
        {
            switch (value)
            {
            case ConstnessT::non_const: return "mutable";
            case ConstnessT::as_const: return "const";
            case ConstnessT::any: return "any";
            }
 
            throw std::invalid_argument{"Unknown constness value."};
        };
 
        return formatter<std::string_view, mimicpp::CharT>::format(
            toString(category),
            ctx);
    }
};
 
namespace mimicpp::custom
{
    template <typename>
    class Printer;
}
 
namespace mimicpp::detail
{
    template <
        print_iterator OutIter,
        typename T,
        printer_for<OutIter, T> Printer = custom::Printer<std::remove_cvref_t<T>>>
    OutIter print(
        OutIter out,
        T&& value,
        [[maybe_unused]] const priority_tag<4>
    )
    {
        return Printer::print(
            std::move(out),
            std::forward<T>(value));
    }
 
    template <typename>
    class Printer;
 
    template <
        print_iterator OutIter,
        typename T,
        printer_for<OutIter, T> Printer = Printer<std::remove_cvref_t<T>>>
    OutIter print(
        OutIter out,
        T&& value,
        [[maybe_unused]] const priority_tag<3>
    )
    {
        return Printer::print(
            std::move(out),
            std::forward<T>(value));
    }
 
    template <print_iterator OutIter, std::ranges::forward_range Range>
    OutIter print(
        OutIter out,
        Range&& range,
        priority_tag<2>
    );
 
    template <print_iterator OutIter, format::detail::formattable<CharT> T>
    OutIter print(
        OutIter out,
        T&& value,
        [[maybe_unused]] const priority_tag<1>
    )
    {
        return format::format_to(
            std::move(out),
            "{}",
            std::forward<T>(value));
    }
 
    template <print_iterator OutIter>
    OutIter print(
        OutIter out,
        auto&&,
        [[maybe_unused]] const priority_tag<0>
    )
    {
        return format::format_to(
            std::move(out),
            "{{?}}");
    }
 
    class PrintFn
    {
    public:
        template <print_iterator OutIter, typename T>
        OutIter operator ()(
            OutIter out,
            T&& value
        ) const
        {
            static_assert(
                requires(const priority_tag<4> tag)
                {
                    { print(out, std::forward<T>(value), tag) } -> std::convertible_to<OutIter>;
                },
                "The given type is not printable. ");
 
            return print(
                std::move(out),
                std::forward<T>(value),
                priority_tag<4>{});
        }
 
        template <typename T>
        StringT operator ()(T&& value) const
        {
            StringStreamT stream{};
            std::invoke(
                *this,
                std::ostreambuf_iterator{stream},
                std::forward<T>(value));
            return std::move(stream).str();
        }
    };
 
    template <print_iterator OutIter, std::ranges::forward_range Range>
    OutIter print(
        OutIter out,
        Range&& range,  // NOLINT(cppcoreguidelines-missing-std-forward)
        const priority_tag<2>
    )
    {
        out = format::format_to(
            std::move(out),
            "{{ ");
        auto iter = std::ranges::begin(range);
        if (const auto end = std::ranges::end(range);
            iter != end)
        {
            constexpr PrintFn print{};
            out = print(std::move(out), *iter++);
 
            for (; iter != end; ++iter)
            {
                out = print(
                    format::format_to(std::move(out), ", "),
                    *iter);
            }
        }
 
        return format::format_to(
            std::move(out),
            " }}");
    }
 
    template <>
    class Printer<std::source_location>
    {
    public:
        template <print_iterator OutIter>
        static OutIter print(OutIter out, const std::source_location& loc)
        {
            return format::format_to(
                std::move(out),
                "{}[{}:{}], {}",
                loc.file_name(),
                loc.line(),
                loc.column(),
                loc.function_name());
        }
    };
 
    template <>
    class Printer<std::nullopt_t>
    {
    public:
        template <print_iterator OutIter>
        static OutIter print(OutIter out, [[maybe_unused]] const std::nullopt_t)
        {
            return format::format_to(
                std::move(out),
                "nullopt");
        }
    };
 
    template <typename T>
    class Printer<std::optional<T>>
    {
    public:
        template <print_iterator OutIter>
        static OutIter print(OutIter out, const std::optional<T>& opt)
        {
            constexpr PrintFn print{};
 
            if (opt)
            {
                out = format::format_to(std::move(out), "{{ value: ");
                out = print(std::move(out), *opt);
                return format::format_to(std::move(out), " }}");
            }
            return print(std::move(out), std::nullopt);
        }
    };
 
    template <std::size_t index, print_iterator OutIter, typename Tuple>
    OutIter tuple_element_print(OutIter out, Tuple&& tuple)
    {
        if constexpr (0u != index)
        {
            out = format::format_to(std::move(out), ", ");
        }
 
        constexpr PrintFn printer{};
        return printer(
            std::move(out), 
            std::get<index>(std::forward<Tuple>(tuple)));
    }
 
    template <typename T>
        requires requires
        {
            typename std::tuple_size<T>::type;
            requires std::convertible_to<typename std::tuple_size<T>::type, std::size_t>;
            requires 0u <= std::tuple_size_v<T>;
        }
    class Printer<T>
    {
    public:
        template <print_iterator OutIter>
        static OutIter print(OutIter out, const T& tuple)
        {
            out = format::format_to(std::move(out), "{{ ");
 
            std::invoke(
                [&]<std::size_t... indices>([[maybe_unused]] const std::index_sequence<indices...>)
                {
                    (...,
                        (out = tuple_element_print<indices>(std::move(out), tuple)));
                },
                std::make_index_sequence<std::tuple_size_v<T>>{});
 
            return format::format_to(std::move(out), " }}");
        }
    };
 
    template <typename T>
    concept pointer_like = std::is_pointer_v<T>
                            || std::same_as<std::nullptr_t, T>;
 
    template <pointer_like T>
        requires (!string<T>)
    class Printer<T>
    {
    public:
        template <print_iterator OutIter>
        static OutIter print(OutIter out, T ptr)
        {
            return format::format_to(
                std::move(out),
                "0x{:0>16x}",
                std::bit_cast<std::uintptr_t>(ptr));
        }
    };
 
    template <string String>
    class Printer<String>
    {
    public:
        template <std::common_reference_with<String> T, print_iterator OutIter>
        static OutIter print(OutIter out, T&& str)
        {
            if constexpr (constexpr auto prefix = string_literal_prefix<string_char_t<String>>;
                !std::ranges::empty(prefix))
            {
                out = out = format::format_to(
                        std::move(out),
                        "{}",
                        prefix);
            }
            
            out = format::format_to(std::move(out), "\"");
 
            // By definition, the string concepts requires the view type to be sized and contiguous.
            // For simplicity, let's always manually convert the view type to an actual std::string_view,
            // which is formattable for sure.
            if constexpr (std::same_as<CharT, string_char_t<String>>)
            {
                auto view = string_traits<String>::view(str);
                out = format::format_to(
                    std::move(out),
                    "{}",
                    StringViewT{
                        std::ranges::data(view),
                        std::ranges::size(view)
                    });
            }
            // required for custom char types
            else if constexpr (printer_for<custom::Printer<string_char_t<String>>, OutIter, string_char_t<String>>)
            {
                for (custom::Printer<string_char_t<String>> printer{};
                    const string_char_t<String>& c : string_traits<String>::view(str))
                {
                    out = printer.print(std::move(out), c);
                }
            }
            else
            {
                constexpr auto to_dump = [](const string_char_t<String>& c) noexcept
                {
                    using intermediate_t = uint_with_size_t<sizeof c>;
                    return std::bit_cast<intermediate_t>(c);
                };
                
 
                auto view = string_traits<std::remove_cvref_t<T>>::view(std::forward<T>(str));
                auto iter = std::ranges::begin(view);
                if (const auto end = std::ranges::end(view);
                    iter != end)
                {
                    out = format::format_to(
                        std::move(out),
                        "{:#x}",
                        to_dump(*iter++));
 
                    for (; iter != end; ++iter)
                    {
                        out = format::format_to(
                            std::move(out),
                            ", {:#x}",
                            to_dump(*iter));
                    }
                }
            }
 
            return format::format_to(std::move(out), "\"");
        }
    };
}
 
namespace mimicpp
{
    [[maybe_unused]] inline constexpr detail::PrintFn print{};
 
}
 
#endif