Condition.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Value.h"
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::decision {
 
enum class ConditionKind : std::uint8_t {
    All,
    Any,
    Not,
    Compare,
    HasTag,
    HasAttribute,
    HasResource,
    StateEquals,
    AuthorityCheck,
    PolicyCall,
};
 
enum class CompareOperator : std::uint8_t {
    Equal,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual,
};
 
enum class DeterminismLevel : std::uint8_t {
    BitExact,
    TickDeterministic,
    ToleranceBounded,
    ExplicitlyNondeterministic,
};
 
struct ScriptConditionDeclaration {
    std::string name;
    std::vector<std::string> dependencies;
    DeterminismLevel determinism = DeterminismLevel::BitExact;
};
 
enum class ConditionReasonCode : std::uint32_t {
    Passed               = 0,
    ChildFailed          = 1,
    NoChildPassed        = 2,
    Negated              = 3,
    MissingValue         = 4,
    ValueMismatch        = 5,
    TagMissing           = 6,
    TagUnavailable       = 7,
    AttributeMissing     = 8,
    ResourceMissing      = 9,
    StateMissing         = 10,
    StateMismatch        = 11,
    AuthorityDenied      = 12,
    AuthorityUnavailable = 13,
    PolicyRejected       = 14,
    PolicyUnavailable    = 15,
    InvalidCondition     = 16,
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION const char* conditionReasonCodeName(ConditionReasonCode code) noexcept;
 
[[nodiscard]] EVENGINE_API_FOUNDATION const char* conditionKindName(ConditionKind kind) noexcept;
 
[[nodiscard]] EVENGINE_API_FOUNDATION const char* compareOperatorName(CompareOperator op) noexcept;
 
class EVENGINE_API_FOUNDATION
    [[nodiscard("ConditionResult must be inspected before the decision is used")]] ConditionResult {
public:
    static ConditionResult success(Value evidence = {}, Value details = Value::Object{});
    static ConditionResult failed(ConditionReasonCode reason, Value evidence = {}, Value details = Value::Object{});
 
    bool passed() const noexcept { return passed_; }
    ConditionReasonCode reasonCode() const noexcept { return reason_; }
    const Value& evidence() const noexcept { return evidence_; }
    const Value& details() const noexcept { return details_; }
 
private:
    ConditionResult(bool passed, ConditionReasonCode reason, Value evidence, Value details)
        : passed_(passed), reason_(reason), evidence_(std::move(evidence)), details_(std::move(details)) {}
 
    bool                passed_ = false;
    ConditionReasonCode reason_ = ConditionReasonCode::InvalidCondition;
    Value               evidence_;
    Value               details_;
};
 
class EvaluationContext {
public:
    virtual ~EvaluationContext() = default;
 
    [[nodiscard]] virtual std::optional<Value> value(std::string_view key) const = 0;
    [[nodiscard]] virtual std::optional<bool> hasTag(std::string_view tag) const = 0;
    [[nodiscard]] virtual std::optional<Value> attribute(std::string_view key) const = 0;
    [[nodiscard]] virtual std::optional<Value> resource(std::string_view key) const = 0;
    [[nodiscard]] virtual std::optional<Value> state(std::string_view key) const = 0;
    [[nodiscard]] virtual std::optional<bool> authority(std::string_view scope) const = 0;
    [[nodiscard]] virtual std::optional<ConditionResult> policy(std::string_view name,
                                                                const Value&     arguments) const = 0;
};
 
class EVENGINE_API_FOUNDATION Condition {
public:
    Condition() = default;
 
    static Condition all(std::vector<Condition> children);
    static Condition any(std::vector<Condition> children);
    static Condition not_(Condition child);
    static Condition compare(std::string key, CompareOperator op, Value expected);
    static Condition hasTag(std::string tag);
    static Condition hasAttribute(std::string attribute);
    static Condition hasResource(std::string resource);
    static Condition stateEquals(std::string key, Value expected);
    static Condition authorityCheck(std::string scope);
    static Condition policyCall(std::string name, Value arguments = Value::Object{},
                                std::optional<ScriptConditionDeclaration> scriptDeclaration = std::nullopt);
 
    ConditionKind kind() const noexcept { return kind_; }
    const std::vector<Condition>& children() const noexcept { return children_; }
    const std::string& key() const noexcept { return key_; }
    CompareOperator compareOperator() const noexcept { return compare_; }
    const Value& expected() const noexcept { return expected_; }
    const Value& arguments() const noexcept { return arguments_; }
    const std::optional<ScriptConditionDeclaration>& scriptDeclaration() const noexcept { return scriptDeclaration_; }
    [[nodiscard]] bool isValid() const noexcept;
    [[nodiscard]] ConditionResult evaluate(const EvaluationContext& context) const;
 
private:
    explicit Condition(ConditionKind kind) : kind_(kind) {}
 
    ConditionKind                             kind_ = ConditionKind::All;
    std::vector<Condition>                    children_;
    std::string                               key_;
    CompareOperator                           compare_ = CompareOperator::Equal;
    Value                                     expected_;
    Value                                     arguments_ = Value::Object{};
    std::optional<ScriptConditionDeclaration> scriptDeclaration_;
};
 
}  // namespace eve::decision