Definitions.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Snapshot.h"
#include "common/Subscription.h"
#include "common/VersionedRegistry.h"
#include "common/definitions/DefinitionRuntime.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::definitions {
 
using DefinitionRef    = eve::DefinitionRef;
using DefinitionHandle = eve::definition::DefinitionHandle;
 
struct Definition {
    std::string type;
    std::string id;
    eve::SchemaVersion version{1};
    // Compatibility projection maintained by VersionedRegistry's generation
    // projector. The registry slot is the authoritative generation owner.
    eve::Generation generation;
    std::string json       = "null";
};
 
struct DefinitionEvent {
    eve::EventSequence sequence;
    std::string name;
    std::string type;
    std::string id;
    eve::SchemaVersion version;
    eve::Generation    generation;
};
 
class EVENGINE_API_FOUNDATION DefinitionRegistry {
public:
    explicit DefinitionRegistry(eve::PersistentId instanceId = {});
 
    using ChangeCallback = std::function<void(const DefinitionEvent&)>;
 
    [[nodiscard]] eve::Result<DefinitionHandle> insert(const std::string& type, const std::string& id, int version,
                                                       const std::string& json);
 
    [[nodiscard]] eve::Result<DefinitionHandle> replace(const std::string& type, const std::string& id, int version,
                                                        const std::string& json);
 
    [[nodiscard]] eve::Result<DefinitionHandle> remove(const std::string& type, const std::string& id);
 
    [[nodiscard]] eve::ResultRef<const Definition> resolve(const std::string& type, const std::string& id) const;
 
    [[nodiscard]] eve::ResultRef<const Definition> resolveHandle(const DefinitionHandle& handle) const;
 
    [[nodiscard]] eve::Result<DefinitionHandle> handle(const std::string& type, const std::string& id) const;
 
    [[nodiscard]] eve::Result<eve::Generation> generationOf(const std::string& type, const std::string& id) const;
 
    [[nodiscard]] bool isTombstone(const std::string& type, const std::string& id) const noexcept;
 
    [[nodiscard]] bool isStale(const DefinitionHandle& handle) const noexcept;
 
    DefinitionRef reference(const std::string& type, const std::string& id) const;
    int size() const;
    int countType(const std::string& type) const;
    const Definition* at(int index) const;
    const Definition* atType(const std::string& type, int index) const;
    int eventCount() const;
    const DefinitionEvent* 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(ChangeCallback callback);
 
private:
    using Key = std::pair<std::string, std::string>;
    struct EventData {
        eve::SchemaVersion version;
    };
    using Storage = eve::VersionedRegistry<Key, Definition, EventData>;
 
    static DefinitionEvent  projectEvent(const Storage::Event& event);
    static DefinitionHandle projectHandle(const Storage::Handle& handle);
    static Storage::Handle  storageHandle(const DefinitionHandle& handle);
    void                    clearEventProjection() const;
 
    Storage                              storage_;
    eve::PersistentId                    instanceId_;
    eve::Revision                        revision_;
    eve::SimulationTick                  tick_;
    mutable std::vector<DefinitionEvent> eventProjection_;
};
 
class Definitions : public Module {
public:
    Module_REG(Definitions);
    Definitions()           = default;
    ~Definitions() override = default;
 
    DefinitionRegistry* newRegistry();
 
private:
    std::vector<std::unique_ptr<DefinitionRegistry>> registries_;
};
 
}  // namespace eve::definitions