Status.h

浏览该文件的文档.

#pragma once
 
#include "common/Diagnostic.h"
#include "common/Export.h"
 
#include <cstdint>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace eve {
 
enum class StatusCode : uint8_t {
    Ok,
    Applied,
    NoOp,
    Pending,
    Rejected,
    Conflict,
    NotFound,
    Unsupported,
    Cancelled,
    Failed,
};
 
[[nodiscard]] constexpr std::string_view statusCodeName(StatusCode code) noexcept {
    switch (code) {
        case StatusCode::Ok: return "ok";
        case StatusCode::Applied: return "applied";
        case StatusCode::NoOp: return "no_op";
        case StatusCode::Pending: return "pending";
        case StatusCode::Rejected: return "rejected";
        case StatusCode::Conflict: return "conflict";
        case StatusCode::NotFound: return "not_found";
        case StatusCode::Unsupported: return "unsupported";
        case StatusCode::Cancelled: return "cancelled";
        case StatusCode::Failed: return "failed";
    }
    return "unknown";
}
 
inline std::ostream& operator<<(std::ostream& stream, StatusCode code) { return stream << statusCodeName(code); }
 
class [[nodiscard("Status must be inspected or explicitly passed onward")]] EVENGINE_API_FOUNDATION Status {
public:
    Status() = default;
 
    Status(StatusCode code, std::vector<Diagnostic> diagnostics) : code_(code), diagnostics_(std::move(diagnostics)) {}
 
    static Status success(StatusCode code = StatusCode::Ok) { return Status(code, {}); }
 
    static Status failure(StatusCode code, Diagnostic diagnostic) {
        std::vector<Diagnostic> diagnostics;
        diagnostics.emplace_back(std::move(diagnostic));
        return Status(code, std::move(diagnostics));
    }
 
    static Status failure(Diagnostic diagnostic) {
        return failure(statusCodeFor(diagnostic.code()), std::move(diagnostic));
    }
 
    StatusCode code() const noexcept { return code_; }
 
    bool isSuccess() const noexcept {
        switch (code_) {
            case StatusCode::Ok:
            case StatusCode::Applied:
            case StatusCode::NoOp:
            case StatusCode::Pending: return true;
            case StatusCode::Rejected:
            case StatusCode::Conflict:
            case StatusCode::NotFound:
            case StatusCode::Unsupported:
            case StatusCode::Cancelled:
            case StatusCode::Failed: return false;
        }
        return false;
    }
 
    bool isFailure() const noexcept { return !isSuccess(); }
 
    bool hasDiagnostics() const noexcept { return !diagnostics_.empty(); }
 
    const std::vector<Diagnostic>& diagnostics() const noexcept { return diagnostics_; }
 
    const Diagnostic* primaryDiagnostic() const noexcept {
        return diagnostics_.empty() ? nullptr : &diagnostics_.front();
    }
 
    std::string describe() const {
        std::string result(statusCodeName(code_));
        if (const Diagnostic* diagnostic = primaryDiagnostic()) {
            result += ": ";
            result += diagnostic->message();
            if (!diagnostic->path().empty()) {
                result += " [";
                result += diagnostic->path();
                result += ']';
            }
        }
        return result;
    }
 
private:
    static StatusCode statusCodeFor(DiagnosticCode code) noexcept {
        switch (code) {
            case DiagnosticCode::InvalidArgument:
            case DiagnosticCode::PreconditionViolation: return StatusCode::Rejected;
            case DiagnosticCode::NotFound: return StatusCode::NotFound;
            case DiagnosticCode::AlreadyExists:
            case DiagnosticCode::Conflict: return StatusCode::Conflict;
            case DiagnosticCode::Unsupported: return StatusCode::Unsupported;
            case DiagnosticCode::Cancelled: return StatusCode::Cancelled;
            case DiagnosticCode::StaleHandle: return StatusCode::Rejected;
            case DiagnosticCode::TypeMismatch: return StatusCode::Rejected;
            case DiagnosticCode::ParseError:
            case DiagnosticCode::SerializationError:
            case DiagnosticCode::InvariantViolation:
            case DiagnosticCode::Failed:
            case DiagnosticCode::HashMismatch:
            case DiagnosticCode::UnknownVersion:
            case DiagnosticCode::CallbackFailure:
            case DiagnosticCode::DialogueNotWaitingForChoice:
            case DiagnosticCode::DialogueNotWaitingForCommand:
            case DiagnosticCode::DialogueConditionRejected:
            case DiagnosticCode::ProcgenGroupDataInvalid:
            case DiagnosticCode::None: return StatusCode::Failed;
            case DiagnosticCode::DialogueRouteNotFound: return StatusCode::NotFound;
        }
        return StatusCode::Failed;
    }
 
    StatusCode              code_ = StatusCode::Ok;
    std::vector<Diagnostic> diagnostics_;
};
 
}  // namespace eve