Snapshot.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Revision.h"
#include "common/SchemaVersion.h"
#include "common/Time.h"
#include "common/Value.h"
 
#include <functional>
#include <map>
#include <string>
#include <string_view>
 
namespace eve {
 
using SnapshotHashProvider = std::function<Result<ContentId>(std::string_view canonicalInput)>;
 
struct EVENGINE_API_FOUNDATION_INLINE SnapshotEnvelope {
    std::string    type;
    LogicalId      schema;
    SchemaVersion  schemaVersion;
    PersistentId   instanceId;
    Revision       revision;
    SimulationTick tick;
    ContentId      contentHash;
    Value          payload;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<SnapshotEnvelope> makeSnapshotEnvelope(
    std::string type, LogicalId schema, SchemaVersion schemaVersion, PersistentId instanceId, Revision revision,
    SimulationTick tick, Value payload, const SnapshotHashProvider& hashProvider);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<std::string> snapshotHashInput(const SnapshotEnvelope& snapshot);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<void> verifySnapshotEnvelope(const SnapshotEnvelope&     snapshot,
                                                                          const SnapshotHashProvider& hashProvider);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<void> validateSnapshotPayloadMetadata(const Value&   payload,
                                                                                   Revision       revision,
                                                                                   SimulationTick tick);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<Value> snapshotEnvelopeValue(const SnapshotEnvelope& snapshot);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<SnapshotEnvelope> parseSnapshotEnvelopeValue(
    const Value& value, const SnapshotHashProvider& hashProvider);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<std::string> serializeSnapshotEnvelope(const SnapshotEnvelope& snapshot);
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<SnapshotEnvelope> parseSnapshotEnvelope(
    std::string_view json, const SnapshotHashProvider& hashProvider);
 
class EVENGINE_API_FOUNDATION SnapshotMigrationChain {
public:
    using Migration = std::function<Result<Value>(const Value& payload)>;
 
    [[nodiscard]] Result<void> add(LogicalId schema, SchemaVersion from, SchemaVersion to, Migration migration);
 
    [[nodiscard]] Result<SnapshotEnvelope> migrate(SnapshotEnvelope snapshot, SchemaVersion targetVersion,
                                                   const SnapshotHashProvider& hashProvider) const;
 
private:
    struct Key {
        std::string   schema;
        std::uint64_t from = 0;
 
        friend bool operator<(const Key& left, const Key& right) noexcept {
            return left.schema < right.schema || (left.schema == right.schema && left.from < right.from);
        }
    };
 
    struct Step {
        SchemaVersion to;
        Migration     migration;
    };
 
    std::map<Key, Step> steps_;
};
 
}  // namespace eve