Diagnostic.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
 
#include <cstdint>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace eve {
 
enum class Severity : uint8_t {
    Info,
    Warning,
    Error,
    Fatal,
};
 
[[nodiscard]] constexpr std::string_view severityName(Severity severity) noexcept {
    switch (severity) {
        case Severity::Info: return "info";
        case Severity::Warning: return "warning";
        case Severity::Error: return "error";
        case Severity::Fatal: return "fatal";
    }
    return "unknown";
}
 
inline std::ostream& operator<<(std::ostream& stream, Severity severity) { return stream << severityName(severity); }
 
enum class DiagnosticCode : uint32_t {
    None                  = 0,
    InvalidArgument       = 1,
    PreconditionViolation = 2,
    NotFound              = 3,
    AlreadyExists         = 4,
    Conflict              = 5,
    Unsupported           = 6,
    Cancelled             = 7,
    StaleHandle           = 8,
    ParseError            = 9,
    SerializationError    = 10,
    InvariantViolation    = 11,
    Failed                = 12,
    HashMismatch          = 13,
    UnknownVersion        = 14,
    CallbackFailure       = 15,
    DialogueNotWaitingForChoice = 16,
    DialogueNotWaitingForCommand = 17,
    DialogueConditionRejected = 18,
    DialogueRouteNotFound = 19,
    ProcgenGroupDataInvalid = 20,
    TypeMismatch = 21,
};
 
using DiagnosticDetail = std::pair<std::string, std::string>;
 
using DiagnosticDetails = std::vector<DiagnosticDetail>;
 
class [[nodiscard("Diagnostic should be inspected or passed to a Result")]] EVENGINE_API_FOUNDATION Diagnostic {
public:
    Diagnostic() = default;
 
    Diagnostic(DiagnosticCode code, Severity severity, std::string message, std::string path = {},
               DiagnosticDetails details = {}, std::string source = {})
        : code_(code),
          severity_(severity),
          message_(std::move(message)),
          path_(std::move(path)),
          details_(std::move(details)),
          source_(std::move(source)) {}
 
    static Diagnostic error(DiagnosticCode code, std::string message, std::string path = {},
                            DiagnosticDetails details = {}, std::string source = {}) {
        return Diagnostic(code, Severity::Error, std::move(message), std::move(path), std::move(details),
                          std::move(source));
    }
 
    static Diagnostic warning(DiagnosticCode code, std::string message, std::string path = {},
                              DiagnosticDetails details = {}, std::string source = {}) {
        return Diagnostic(code, Severity::Warning, std::move(message), std::move(path), std::move(details),
                          std::move(source));
    }
 
    DiagnosticCode code() const noexcept { return code_; }
    Severity severity() const noexcept { return severity_; }
    const std::string& message() const noexcept { return message_; }
    const std::string& path() const noexcept { return path_; }
    const DiagnosticDetails& details() const noexcept { return details_; }
    const std::string& source() const noexcept { return source_; }
 
    void addDetail(std::string key, std::string value) { details_.emplace_back(std::move(key), std::move(value)); }
 
    bool isError() const noexcept { return severity_ == Severity::Error || severity_ == Severity::Fatal; }
 
private:
    DiagnosticCode    code_     = DiagnosticCode::None;
    Severity          severity_ = Severity::Info;
    std::string       message_;
    std::string       path_;
    DiagnosticDetails details_;
    std::string       source_;
};
 
[[nodiscard]] constexpr std::string_view diagnosticCodeName(DiagnosticCode code) noexcept {
    switch (code) {
        case DiagnosticCode::None: return "none";
        case DiagnosticCode::InvalidArgument: return "invalid_argument";
        case DiagnosticCode::PreconditionViolation: return "precondition_violation";
        case DiagnosticCode::NotFound: return "not_found";
        case DiagnosticCode::AlreadyExists: return "already_exists";
        case DiagnosticCode::Conflict: return "conflict";
        case DiagnosticCode::Unsupported: return "unsupported";
        case DiagnosticCode::Cancelled: return "cancelled";
        case DiagnosticCode::StaleHandle: return "stale_handle";
        case DiagnosticCode::ParseError: return "parse_error";
        case DiagnosticCode::SerializationError: return "serialization_error";
        case DiagnosticCode::InvariantViolation: return "invariant_violation";
        case DiagnosticCode::Failed: return "failed";
        case DiagnosticCode::HashMismatch: return "hash_mismatch";
        case DiagnosticCode::UnknownVersion: return "unknown_version";
        case DiagnosticCode::CallbackFailure: return "callback_failure";
        case DiagnosticCode::DialogueNotWaitingForChoice: return "dialogue_not_waiting_for_choice";
        case DiagnosticCode::DialogueNotWaitingForCommand: return "dialogue_not_waiting_for_command";
        case DiagnosticCode::DialogueConditionRejected: return "dialogue_condition_rejected";
        case DiagnosticCode::DialogueRouteNotFound: return "dialogue_route_not_found";
        case DiagnosticCode::ProcgenGroupDataInvalid: return "procgen_group_data_invalid";
        case DiagnosticCode::TypeMismatch: return "type_mismatch";
    }
    return "unknown";
}
 
inline std::ostream& operator<<(std::ostream& stream, DiagnosticCode code) {
    return stream << diagnosticCodeName(code);
}
 
}  // namespace eve