PolicyRegistry.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Snapshot.h"
#include "common/Subscription.h"
#include "common/VersionedRegistry.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::policyregistry {
 
enum class ImplementationKind { Builtin, Script, Batch };
 
struct PolicyHandle {
    std::string     domain;
    std::string     name;
    eve::Generation generation;
};
 
struct PolicyDescriptor {
    std::string        domain;
    std::string        name;
    eve::SchemaVersion version{1};
    int                priority = 0;
    bool               enabled  = true;
    ImplementationKind kind     = ImplementationKind::Script;
    std::string        schemaId;
    std::string        metadataJson = "{}";
    // Compatibility projection; the VersionedRegistry slot owns generation.
    eve::Generation generation;
};
 
struct PolicyEvent {
    eve::EventSequence sequence;
    std::string        name;
    std::string        domain;
    std::string        policyName;
    eve::SchemaVersion version;
    eve::Generation    generation;
    bool               enabled = false;
};
 
class EVENGINE_API_FOUNDATION PolicyRegistry {
public:
    explicit PolicyRegistry(eve::PersistentId instanceId = {});
 
    [[nodiscard]] eve::Result<PolicyHandle> insert(const std::string& domain, const std::string& name, int version,
                                                   int priority, bool enabled, const std::string& kind,
                                                   const std::string& schemaId, const std::string& metadataJson);
    [[nodiscard]] eve::Result<PolicyHandle> replace(const std::string& domain, const std::string& name, int version,
                                                    int priority, bool enabled, const std::string& kind,
                                                    const std::string& schemaId, const std::string& metadataJson);
    [[nodiscard]] eve::Result<PolicyHandle> remove(const std::string& domain, const std::string& name);
    [[nodiscard]] eve::Result<PolicyHandle> enable(const std::string& domain, const std::string& name, bool enabled);
    [[nodiscard]] eve::ResultRef<const PolicyDescriptor> resolve(const std::string& domain,
                                                                 const std::string& name) const;
    [[nodiscard]] eve::ResultRef<const PolicyDescriptor> resolveHandle(const PolicyHandle& handle) const;
    [[nodiscard]] eve::Result<PolicyHandle> handle(const std::string& domain, const std::string& name) const;
    [[nodiscard]] eve::Result<eve::Generation> generationOf(const std::string& domain, const std::string& name) const;
    [[nodiscard]] bool isTombstone(const std::string& domain, const std::string& name) const noexcept;
    [[nodiscard]] bool isStale(const PolicyHandle& handle) const noexcept;
 
    const PolicyDescriptor* select(const std::string& domain) const;
    int size() const;
    int countDomain(const std::string& domain) const;
    const PolicyDescriptor* at(int index) const;
    const PolicyDescriptor* atDomain(const std::string& domain, int index) const;
    int eventCount() const;
    const PolicyEvent* eventAt(int index) const;
    void clearEvents();
    std::string snapshotJson() const;
    [[nodiscard]] eve::Result<void> restoreJson(const std::string& json);
 
    [[nodiscard]] eve::Result<eve::SnapshotEnvelope> snapshot(const eve::SnapshotHashProvider& hashProvider) const;
    [[nodiscard]] eve::Result<void> restoreSnapshot(const eve::SnapshotEnvelope&     snapshot,
                                                    const eve::SnapshotHashProvider& hashProvider);
    [[nodiscard]] eve::Result<std::string> snapshotEnvelopeJson(const eve::SnapshotHashProvider& hashProvider) const;
    [[nodiscard]] eve::Result<void> restoreSnapshotJson(std::string_view                 json,
                                                        const eve::SnapshotHashProvider& hashProvider);
 
    [[nodiscard("retain Subscription or explicitly dispose it")]] eve::Subscription subscribe(
        std::function<void(const PolicyEvent&)> callback);
 
private:
    using Key = std::pair<std::string, std::string>;
    struct EventData {
        eve::SchemaVersion version;
        bool               enabled = false;
    };
    using Storage = eve::VersionedRegistry<Key, PolicyDescriptor, EventData>;
 
    static PolicyEvent     projectEvent(const Storage::Event& event);
    static PolicyHandle    projectHandle(const Storage::Handle& handle);
    static Storage::Handle storageHandle(const PolicyHandle& handle);
    void                   clearEventProjection() const;
 
    Storage                          storage_;
    eve::PersistentId                instanceId_;
    eve::Revision                    revision_;
    eve::SimulationTick              tick_;
    mutable std::vector<PolicyEvent> eventProjection_;
};
 
EVENGINE_API_FOUNDATION std::string implementationKindName(ImplementationKind kind);
bool parseImplementationKind(const std::string& name, ImplementationKind& kind);
 
class PolicyRegistryModule : public Module {
public:
    Module_REG(PolicyRegistryModule);
    PolicyRegistryModule()           = default;
    ~PolicyRegistryModule() override = default;
 
    PolicyRegistry* newRegistry();
 
private:
    std::vector<std::unique_ptr<PolicyRegistry>> registries_;
};
 
}  // namespace eve::policyregistry