RuleEngine.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Result.h"
#include "common/SquirrelOwnership.h"
#include "emergence/FactStore.h"
#include "emergence/RuleTypes.h"
#include "emergence/WatchIndex.h"
 
#include <cstdint>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace eve::emergence {
 
struct RuleEngineHandleTag {};
using RuleEngineHandleRef = eve::script::RuntimeHandleRef<RuleEngineHandleTag>;
 
class EVENGINE_API_FOUNDATION RuleEngine {
public:
    RuleEngine()  = default;
    ~RuleEngine() = default;
 
    RuleEngine(const RuleEngine&)            = delete;
    RuleEngine& operator=(const RuleEngine&) = delete;
    RuleEngine(RuleEngine&&)                 = default;
    RuleEngine& operator=(RuleEngine&&)      = default;
 
    [[nodiscard]] eve::Result<int> replaceCatalogue(std::vector<RuleDefinition> rules);
 
    [[nodiscard]] eve::Result<int> replaceCatalogueJson(std::string_view json);
 
    void clear();
 
    [[nodiscard]] int ruleCount() const noexcept { return static_cast<int>(rules_.size()); }
    [[nodiscard]] bool contains(std::string_view ruleId) const;
    [[nodiscard]] const RuleDefinition* find(std::string_view ruleId) const;
 
    [[nodiscard]] const FactStore& facts() const noexcept { return facts_; }
 
    [[nodiscard]] eve::Result<bool> setValue(std::string key, eve::Value value);
    [[nodiscard]] eve::Result<bool> setTag(std::string tag, bool present);
    [[nodiscard]] eve::Result<bool> setAttribute(std::string key, eve::Value value);
    [[nodiscard]] eve::Result<bool> setResource(std::string key, eve::Value value);
    [[nodiscard]] eve::Result<bool> setState(std::string key, eve::Value value);
    [[nodiscard]] eve::Result<bool> setAuthority(std::string scope, bool granted);
    [[nodiscard]] eve::Result<bool> setPolicy(std::string name, decision::ConditionResult result);
 
    [[nodiscard]] eve::Result<int> drain(std::uint64_t tick);
 
    [[nodiscard]] int activationCount() const noexcept { return static_cast<int>(activations_.size()); }
    [[nodiscard]] const Activation* activationAt(int index) const;
    void clearActivations();
 
    [[nodiscard]] eve::Result<void> resetRule(std::string_view ruleId);
 
    [[nodiscard]] int dirtyCount() const noexcept { return static_cast<int>(dirty_.size()); }
    [[nodiscard]] std::uint64_t lastDrainEvaluations() const noexcept { return lastDrainEvaluations_; }
    [[nodiscard]] std::uint64_t wakeKeyEvents() const noexcept { return wakeKeyEvents_; }
 
    [[nodiscard]] std::string snapshotJson() const;
    [[nodiscard]] eve::Result<void> restoreJson(std::string_view json);
 
private:
    struct RuleRuntime {
        bool          passed        = false;
        bool          fired         = false;
        bool          disabled      = false;
        std::uint64_t cooldownUntil = 0;
    };
 
    void                            wakeKey(std::string_view key);
    [[nodiscard]] eve::Result<void> executeActions(const std::vector<EmergenceAction>& actions, std::uint64_t tick);
    [[nodiscard]] eve::Result<void> executeOne(const EmergenceAction& action, std::uint64_t tick);
    [[nodiscard]] static eve::Result<RuleDefinition> validateAndNormalize(RuleDefinition rule);
 
    FactStore                                      facts_;
    WatchIndex                                     watchIndex_;
    std::vector<RuleDefinition>                    rules_;
    std::vector<RuleRuntime>                       runtime_;
    std::unordered_map<std::string, std::uint32_t> idToIndex_;
    std::unordered_set<std::uint32_t>              dirty_;
    std::vector<Activation>                        activations_;
    std::uint64_t                                  nextSequence_         = 1;
    std::uint64_t                                  lastDrainEvaluations_ = 0;
    std::uint64_t                                  wakeKeyEvents_        = 0;
    bool                                           draining_             = false;
};
 
}  // namespace eve::emergence