StatePatch.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Result.h"
#include "common/Snapshot.h"
#include "common/SquirrelOwnership.h"
#include "transaction/Transaction.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::statepatch {
 
class StatePatchStateAdapter;
 
struct StateStoreHandleTag {};
using StateStoreHandleRef = eve::script::RuntimeHandleRef<StateStoreHandleTag>;
struct PatchBatchHandleTag {};
using PatchBatchHandleRef = eve::script::RuntimeHandleRef<PatchBatchHandleTag>;
 
struct StateBatchHandleRef {
    StateStoreHandleRef store;
    PatchBatchHandleRef batch;
    std::uint64_t       ownerEpoch = 0;
 
    [[nodiscard]] constexpr std::uint64_t packed() const noexcept { return batch.packed(); }
    [[nodiscard]] constexpr bool isValid() const noexcept {
        return store.isValid() && batch.isValid() && ownerEpoch != 0;
    }
};
 
class StoreTransactionParticipant;
 
struct PatchError {
    int         operationIndex = -1;
    std::string subject;
    std::string key;
    std::string code;
    std::string message;
};
 
struct PatchResult {
    bool                    success        = false;
    int                     changedCount   = 0;
    uint64_t                revisionBefore = 0;
    uint64_t                revisionAfter  = 0;
    std::vector<PatchError> errors;
};
 
struct ChangeEvent {
    uint64_t    sequence = 0;
    uint64_t    revision = 0;
    std::string subject;
    std::string key;
    std::string oldJson;
    std::string newJson;
    bool        removed = false;
};
 
class EVENGINE_API_FOUNDATION PatchBatch {
public:
    bool set(const std::string& subject, const std::string& key, const std::string& jsonValue);
    bool setExpected(const std::string& subject, const std::string& key, const std::string& jsonValue,
                     const std::string& expectedJson);
    bool remove(const std::string& subject, const std::string& key);
    bool removeExpected(const std::string& subject, const std::string& key, const std::string& expectedJson);
    void clear();
    int size() const;
    const PatchResult& result() const;
 
private:
    friend class Store;
    struct Operation {
        bool                       remove = false;
        std::string                subject;
        std::string                key;
        std::string                value;
        std::optional<std::string> expected;
        std::string                inputError;
    };
    std::vector<Operation> operations_;
    PatchResult            result_;
};
 
class EVENGINE_API_FOUNDATION Store {
public:
    explicit Store(eve::PersistentId instanceId = {});
    [[nodiscard]] eve::Result<PatchBatchHandleRef> newBatch();
    [[nodiscard]] eve::script::Borrowed<PatchBatch> resolveBatch(PatchBatchHandleRef reference) noexcept;
    [[nodiscard]] eve::Result<void> releaseBatch(PatchBatchHandleRef reference);
    [[nodiscard]] bool isBatchStale(PatchBatchHandleRef reference) const noexcept;
    bool commit(PatchBatch* batch);
    bool has(const std::string& subject, const std::string& key) const;
    std::string get(const std::string& subject, const std::string& key) const;
    uint64_t valueRevision(const std::string& subject, const std::string& key) const;
    uint64_t revision() const;
    int querySubjects();
    int queryKeys(const std::string& subject);
    std::string queryAt(int index) const;
    int queryDirty();
    std::string dirtySubjectAt(int index) const;
    std::string dirtyKeyAt(int index) const;
    void clearDirty();
    int eventCount() const;
    const ChangeEvent* 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);
 
private:
    friend class StoreTransactionParticipant;
 
    struct Value {
        std::string json;
        uint64_t    revision = 0;
    };
    using Values = std::map<std::string, std::map<std::string, Value>>;
 
    Values                                           values_;
    uint64_t                                         revision_     = 0;
    uint64_t                                         nextSequence_ = 1;
    eve::PersistentId                                                   instanceId_;
    eve::SimulationTick                                                 tick_;
    std::set<std::pair<std::string, std::string>>    dirty_;
    std::vector<ChangeEvent>                         events_;
    std::vector<std::string>                         query_;
    std::vector<std::pair<std::string, std::string>> dirtyQuery_;
    eve::script::RuntimeObjectRegistry<PatchBatch, PatchBatchHandleTag> batches_;
    void                                                                copyTransactionStateFrom(const Store& source);
    void                                                                swapTransactionState(Store& other) noexcept;
    bool transactionStateEquals(const Store& other) const;
};
 
class EVENGINE_API_FOUNDATION StoreTransactionParticipant final : public transaction::ITransactionParticipant {
public:
    StoreTransactionParticipant(Store& store, PatchBatch& batch) : store_(store), batch_(batch) {}
    ~StoreTransactionParticipant() override = default;
 
    std::string_view name() const noexcept override { return "statepatch.store"; }
 
    [[nodiscard]] eve::Result<void> prepare(const transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> commit(const transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> rollback(const transaction::TransactionContext& context) override;
    [[nodiscard]] eve::Result<void> compensate(const transaction::TransactionContext& context) override;
 
private:
    enum class Phase { Idle, Prepared, Committed, RolledBack, Compensated, Failed };
 
    [[nodiscard]] eve::Result<void> lifecycleFailure(std::string_view operation) const;
    [[nodiscard]] eve::Result<void> contextFailure(const transaction::TransactionContext& context) const;
    bool                            contextMatches(const transaction::TransactionContext& context) const noexcept;
 
    Store&                 store_;
    PatchBatch&            batch_;
    std::unique_ptr<Store> before_;
    std::unique_ptr<Store> prepared_;
    std::unique_ptr<Store> expectedAfter_;
    std::string            transactionId_;
    std::string            correlationId_;
    std::string            causationId_;
    Phase                  phase_ = Phase::Idle;
};
 
class StatePatch : public Module {
public:
    Module_REG(StatePatch);
    StatePatch() = default;
    ~StatePatch() override;
 
    [[nodiscard]] static eve::Result<StateStoreHandleRef> newStore();
    [[nodiscard]] static eve::script::Borrowed<Store> resolve(StateStoreHandleRef reference) noexcept;
    [[nodiscard]] static eve::Result<void> release(StateStoreHandleRef reference);
    [[nodiscard]] static bool isStale(StateStoreHandleRef reference) noexcept;
 
    [[nodiscard]] static eve::script::Borrowed<PatchBatch> resolveBatch(StateBatchHandleRef reference) noexcept;
    [[nodiscard]] static eve::Result<void> releaseBatch(StateBatchHandleRef reference);
    [[nodiscard]] static bool isBatchStale(StateBatchHandleRef reference) noexcept;
 
private:
    void attachWorldAdapter(Store& store);
    void detachWorldAdapter(Store& store);
 
    eve::script::RuntimeObjectRegistry<Store, StateStoreHandleTag> stores_;
    std::unordered_map<Store*, std::unique_ptr<StatePatchStateAdapter>> worldAdapters_;
};
 
}  // namespace eve::statepatch