diagnostics.hpp

Go to the documentation of this file.

#pragma once
 
#include <any>
#include <functional>
#include <sstream>
#include <string>
#include <unordered_set>
 
#include <fmt/color.h>
#include <fmt/ranges.h>
 
namespace porytiles {
 
enum class DiagLevel {
    kIgnored,
    kNote,
    kRemark,
    kWarning,
    kError,
    kFatal
};
 
std::string LevelToStr(DiagLevel level);
 
fmt::terminal_color ColorForLevel(DiagLevel level);
 
int LevelPriority(DiagLevel level);
 
// The full definition for this class is in diagnostics/diagnostic_engine.hpp.
class DiagEngine;
 
using DynamicMsgBuilder = std::function<std::vector<std::string>(const DiagEngine &eng, DiagLevel in_flight_level,
                                                                 const std::vector<std::any> &args)>;
 
class DiagTempl {
  public:
    // clang-format off
    explicit DiagTempl(std::string_view name, DiagLevel default_level,
                      DynamicMsgBuilder dynamic_msg_builder) noexcept
        : name_{name},
          default_level_{default_level},
          dynamic_msg_builder_{std::move(dynamic_msg_builder)} {}
 
    explicit DiagTempl(std::string_view name, DiagLevel default_level,
                        DynamicMsgBuilder dynamic_msg_builder, const std::vector<DiagTempl> &partner_diags) noexcept
        : name_{name},
          default_level_{default_level},
          dynamic_msg_builder_{std::move(dynamic_msg_builder)},
          partner_diags_{partner_diags} {}
 
    explicit DiagTempl(std::string_view name, DiagLevel default_level,
                    std::string_view static_msg_templ) noexcept
        : name_{name},
          default_level_{default_level},
          static_msg_templ_{static_msg_templ},
          dynamic_msg_builder_{nullptr} {}
 
    explicit DiagTempl(std::string_view name, DiagLevel default_level,
                        std::string_view static_msg_templ, const std::vector<DiagTempl> &partner_diags) noexcept
        : name_{name},
          default_level_{default_level},
          static_msg_templ_{static_msg_templ},
          dynamic_msg_builder_{nullptr},
          partner_diags_{partner_diags} {}
    // clang-format on
 
    [[nodiscard]] std::string_view name() const {
        return name_;
    }
 
    [[nodiscard]] DiagLevel level() const {
        return default_level_;
    }
 
    [[nodiscard]] std::string_view static_msg_templ() const {
        return static_msg_templ_;
    }
 
    template <typename... Args>
    std::vector<std::string> BuildDynamicMsg(const DiagEngine &eng, const DiagLevel in_flight_level,
                                             Args &&...args) const {
        if (dynamic_msg_builder_ == nullptr) {
            std::vector<std::string> v{};
            v.push_back(fmt::format(fmt::runtime(static_msg_templ_), std::forward<Args>(args)...));
            return v;
        }
        const std::vector<std::any> v{std::forward<Args>(args)...};
        return dynamic_msg_builder_(eng, in_flight_level, v);
    }
 
    [[nodiscard]] const std::vector<DiagTempl> &partner_diags() const {
        return partner_diags_;
    }
 
  private:
    std::string name_;
    DiagLevel default_level_;
    std::string_view static_msg_templ_;
    DynamicMsgBuilder dynamic_msg_builder_;
    std::vector<DiagTempl> partner_diags_;
};
 
class InFlightDiag {
  public:
    explicit InFlightDiag(const DiagLevel level, std::string msg, DiagTempl templ) noexcept
        : level_{level}, msg_{std::move(msg)}, templ_{std::move(templ)} {}
 
    [[nodiscard]] DiagLevel level() const noexcept {
        return level_;
    }
 
    [[nodiscard]] std::string msg() const noexcept {
        return msg_;
    }
 
    [[nodiscard]] const DiagTempl &templ() const noexcept {
        return templ_;
    }
 
  private:
    DiagLevel level_;
    std::string msg_;
    DiagTempl templ_;
};
 
class DiagConsumer {
  public:
    virtual ~DiagConsumer() = default;
    virtual void Consume(const InFlightDiag &diag) = 0;
    [[nodiscard]] virtual bool IsATty() const = 0;
    [[nodiscard]] virtual InFlightDiag ConsumedAt(std::size_t i) const = 0;
    [[nodiscard]] virtual std::uint64_t ConsumedCount() const = 0;
};
 
class IgnoreConsumer final : public DiagConsumer {
  public:
    void Consume(const InFlightDiag &diag) override;
    [[nodiscard]] bool IsATty() const override;
    [[nodiscard]] InFlightDiag ConsumedAt(std::size_t i) const override;
    [[nodiscard]] std::uint64_t ConsumedCount() const override;
 
  private:
    std::uint64_t consumed_count_{};
};
 
class StderrConsumer final : public DiagConsumer {
  public:
    void Consume(const InFlightDiag &diag) override;
    [[nodiscard]] bool IsATty() const override;
    [[nodiscard]] InFlightDiag ConsumedAt(std::size_t i) const override;
    [[nodiscard]] std::uint64_t ConsumedCount() const override;
 
  private:
    std::uint64_t consumed_count_{};
};
 
class VectorConsumer final : public DiagConsumer {
  public:
    void Consume(const InFlightDiag &diag) override;
    [[nodiscard]] bool IsATty() const override;
    [[nodiscard]] InFlightDiag ConsumedAt(std::size_t i) const override;
    [[nodiscard]] std::uint64_t ConsumedCount() const override;
 
  private:
    std::vector<InFlightDiag> diags_;
};
 
// clang-format off
 
constexpr auto NoteGeneric = "note-generic";
 
constexpr auto WarnColorPrecisionLoss = "color-precision-loss";
constexpr auto WarnKeyFrameNoMatchingTile = "key-frame-no-matching-tile";
constexpr auto WarnKeyFrameMissingColors = "key-frame-missing-colors";
constexpr auto WarnAttributeFormatMismatch = "attribute-format-mismatch";
constexpr auto WarnMissingAttributesCsv = "missing-attributes-csv";
constexpr auto WarnUnusedAttribute = "unused-attribute";
constexpr auto WarnTransparencyCollapse = "transparency-collapse";
constexpr auto WarnUnusedManualPalColor = "unused-manual-pal-color";
constexpr auto WarnTileIndexOutOfRange = "tile-index-out-of-range";
constexpr auto WarnPaletteIndexOutOfRange = "palette-index-out-of-range";
 
 
constexpr auto ErrGeneric = "error-generic";
constexpr auto FatalGeneric = "error-fatal-generic";
 
// clang-format on
 
DiagTempl DiagFor(std::string_view name);
 
std::vector<const char *> AllDiagNames();
 
std::vector<const char *> AllDiagNames(DiagLevel level);
 
} // namespace porytiles
 
template <>
struct std::hash<porytiles::DiagTempl> {
    std::size_t operator()(const porytiles::DiagTempl &templ) const noexcept {
        std::size_t seed = 0x39A9C07E;
        seed ^= (seed << 6) + (seed >> 2) + 0x6EFC4121 + std::hash<std::string>{}(std::string{templ.name()});
        seed ^= (seed << 6) + (seed >> 2) + 0x14AA7601 + static_cast<std::size_t>(templ.level());
        return seed;
    }
};