user_diagnostics.hpp

Go to the documentation of this file.

#pragma once
 
#include <ranges>
#include <string>
 
#include "porytiles2/xcut/panic/panic.hpp"
#include "porytiles2/xcut/result/chainable_result.hpp"
#include "porytiles2/xcut/result/error.hpp"
 
namespace porytiles2 {
 
class UserDiagnostics {
  public:
    virtual ~UserDiagnostics() = default;
 
    void note(const std::string &tag, const std::string &msg) const
    {
        note(tag, std::vector{msg});
    }
 
    virtual void note(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void warn_note(const std::string &tag, const std::string &msg) const
    {
        warn_note(tag, std::vector{msg});
    }
 
    virtual void warn_note(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    void warn(const std::string &tag, const std::string &msg) const
    {
        warn(tag, std::vector{msg});
    }
 
    virtual void warn(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    // /**
    //  * @brief Display a tagged warning message using a formatter-aware builder function.
    //  *
    //  * @details
    //  * This overload allows callers to provide a function that dynamically generates warning messages with access to
    //  * text formatting capabilities. The TextFormatter is provided to enable conditional styling based on TTY output
    //  * settings.
    //  *
    //  * @param tag Categorization tag for the warning
    //  * @param msg_builder Function that receives a TextFormatter reference and returns formatted message lines
    //  */
    // void warn(const std::string &tag, const FormattedMessageBuilder &msg_builder) const
    // {
    //     // TODO: inject this formatter
    //     AnsiStyledTextFormatter formatter{};
    //     warn(tag, msg_builder(formatter));
    // }
 
    void err(const std::string &tag, const std::string &msg) const
    {
        err(tag, std::vector{msg});
    }
 
    virtual void err(const std::string &tag, const std::vector<std::string> &lines) const = 0;
 
    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());
        }
 
        // If all errors were blank FormattableErrors (defensive, shouldn't happen), return early
        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());
        }
    }
};
 
} // namespace porytiles2