user_diagnostics.hpp

Go to the documentation of this file.

#pragma once
 
#include <ranges>
#include <string>
#include <type_traits>
 
#include "gsl/pointers"
 
#include "porytiles/utilities/panic/panic.hpp"
#include "porytiles/utilities/result/chainable_result.hpp"
#include "porytiles/utilities/result/error.hpp"
#include "porytiles/utilities/text/text_formatter.hpp"
#include "porytiles/xcut/config/config_value.hpp"
 
namespace porytiles {
 
class UserDiagnostics {
  public:
    virtual ~UserDiagnostics() = default;
 
    explicit UserDiagnostics(gsl::not_null<const TextFormatter *> format) : format_(format) {}
 
    virtual void remark(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void remark(const std::string &tag, const std::string &msg) const
    {
        remark(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void remark(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        remark(tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void warning(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void warning(const std::string &tag, const std::string &msg) const
    {
        warning(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void warning(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        warning(
            tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void error(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void error(const std::string &tag, const std::string &msg) const
    {
        error(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void error(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        error(tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void remark_note(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void remark_note(const std::string &tag, const std::string &msg) const
    {
        remark_note(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void
    remark_note(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        remark_note(
            tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void warning_note(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void warning_note(const std::string &tag, const std::string &msg) const
    {
        warning_note(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void
    warning_note(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        warning_note(
            tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void error_note(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void error_note(const std::string &tag, const std::string &msg) const
    {
        error_note(tag, std::vector{msg});
    }
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    void
    error_note(const std::string &tag, const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        error_note(
            tag, formatter().format(format_str, std::forward<FirstParam>(first), std::forward<RestParams>(rest)...));
    }
 
    virtual void emit_fatal_proximate(const Error &err) const = 0;
 
    virtual void emit_fatal_step(const Error &err) const = 0;
 
    virtual void emit_fatal_root(const Error &err) const = 0;
 
    template <typename T, typename E>
    void fatal(const ChainableResult<T, E> &result) const
    {
        // Preconditions
        const auto &chain = result.chain();
        assert_or_panic(!result.has_value(), "result was not of error type");
        assert_or_panic(!chain.empty(), "error chain was empty");
 
        // filter out FormattableErrors with no details
        auto filtered_view = chain | std::views::filter([](const auto &err) {
                                 const auto formattable_err = dynamic_cast<const FormattableError *>(err.get());
                                 if (formattable_err == nullptr) {
                                     return true;
                                 }
                                 return formattable_err->has_details();
                             });
 
        std::vector<const Error *> filtered_chain;
        for (const auto &err : filtered_view) {
            filtered_chain.push_back(err.get());
        }
 
        // Unreachable.
        if (filtered_chain.empty()) {
            panic("filtered error chain was empty, there should always be at least one FormattableError with details");
        }
 
        emit_fatal_proximate(*filtered_chain.at(0));
        if (filtered_chain.size() > 1) {
            // Emit steps for all but the first and last
            const auto middle_range =
                std::ranges::views::drop(filtered_chain, 1) | std::ranges::views::take(filtered_chain.size() - 2);
            for (const auto *err : middle_range) {
                emit_fatal_step(*err);
            }
            // Emit the last one as root
            emit_fatal_root(*filtered_chain.back());
        }
    }
 
    [[nodiscard]] const TextFormatter &formatter() const
    {
        return *format_;
    }
 
  private:
    const TextFormatter *format_;
};
 
} // namespace porytiles