EvpackRegistry.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "asset/EvpackResourceReader.h"
 
#include <map>
#include <memory>
#include <mutex>
#include <functional>
 
namespace eve::asset {
 
struct EvpackHandle {
    PersistentId packageId;
    PersistentId buildId;
    std::uint64_t generation = 0;
 
    friend bool operator==(const EvpackHandle&, const EvpackHandle&) noexcept = default;
};
 
struct EvpackChunkHandle {
    EvpackHandle package;
    std::uint32_t chunkIndex = 0;
};
 
struct EvpackAssetHandle {
    EvpackHandle       package;
    AssetRef           asset;
    std::string        expectedType;
    EvpackCapabilities capabilities;
};
 
struct EvpackMountReceipt {
    EvpackHandle handle;
    bool         replacedExisting = false;
    std::vector<Diagnostic> callbackDiagnostics;
};
 
enum class EvpackRegistryEventKind : std::uint8_t { Mounted, Replaced, Unmounted };
 
struct EvpackRegistryEvent {
    EvpackRegistryEventKind kind = EvpackRegistryEventKind::Mounted;
    EvpackHandle            handle;
};
 
struct EvpackRegistrySubscription {
    std::uint64_t value = 0;
    friend bool operator==(const EvpackRegistrySubscription&,
                           const EvpackRegistrySubscription&) noexcept = default;
};
 
struct EvpackUnmountReceipt {
    EvpackHandle            handle;
    std::vector<Diagnostic> callbackDiagnostics;
};
 
class PreparedEvpackMount {
public:
    PreparedEvpackMount(PreparedEvpackMount&&) noexcept = default;
    PreparedEvpackMount& operator=(PreparedEvpackMount&&) noexcept = default;
    PreparedEvpackMount(const PreparedEvpackMount&) = delete;
    PreparedEvpackMount& operator=(const PreparedEvpackMount&) = delete;
 
    [[nodiscard]] const PersistentId& packageId() const noexcept { return pack_->packageId(); }
    [[nodiscard]] const PersistentId& buildId() const noexcept { return pack_->buildId(); }
 
private:
    friend EVENGINE_API_FOUNDATION Result<PreparedEvpackMount> prepareEvpackMount(std::span<const std::uint8_t>,
                                                                                  const EvpackLimits&,
                                                                                  const EvpackTrust&);
    friend class EvpackRegistry;
    explicit PreparedEvpackMount(std::shared_ptr<const Evpack> pack) : pack_(std::move(pack)) {}
    std::shared_ptr<const Evpack> pack_;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION Result<PreparedEvpackMount> prepareEvpackMount(
    std::span<const std::uint8_t> bytes, const EvpackLimits& limits = {}, const EvpackTrust& trust = {});
 
class EVENGINE_API_FOUNDATION EvpackRegistry {
public:
    using Callback = std::function<Result<void>(const EvpackRegistryEvent&)>;
 
    [[nodiscard]] Result<EvpackRegistrySubscription> subscribe(Callback callback);
 
    [[nodiscard]] Result<void> unsubscribe(EvpackRegistrySubscription subscription);
 
    [[nodiscard]] Result<EvpackMountReceipt> commit(PreparedEvpackMount candidate);
 
    [[nodiscard]] Result<std::shared_ptr<const Evpack>> resolve(const EvpackHandle& handle) const;
 
    [[nodiscard]] Result<EvpackAssetHandle> resolveAsset(
        const AssetRef& asset, std::string_view expectedType,
        const EvpackCapabilities& capabilities) const;
 
    [[nodiscard]] Result<RuntimeAssetPayload> readAsset(
        const EvpackAssetHandle& handle, std::uint64_t maximumDecodedBytes) const;
 
    [[nodiscard]] Result<EvpackChunkHandle> resolveChunk(
        const EvpackHandle& handle, const PersistentId& assetId, std::string_view type,
        EvpackChunkKind kind, std::uint32_t chunkId, std::uint32_t variantIndex) const;
 
    [[nodiscard]] Result<std::vector<std::uint8_t>> copyChunkBytes(const EvpackChunkHandle& handle) const;
 
    [[nodiscard]] Result<EvpackUnmountReceipt> unmount(const EvpackHandle& handle);
 
private:
    struct Entry {
        std::shared_ptr<const Evpack> pack;
        std::uint64_t generation = 0;
    };
    mutable std::mutex             mutex_;
    std::map<PersistentId, Entry> packages_;
    std::map<PersistentId, std::uint64_t> nextGenerations_;
    std::map<std::uint64_t, Callback> callbacks_;
    std::uint64_t nextSubscription_ = 0;
};
 
}  // namespace eve::asset