PixelWorldTransport.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "pixelworld/PixelWorld.h"
#include "pixelworld/streaming/PixelWorldStreaming.h"
 
#include <cstdint>
#include <map>
#include <memory>
#include <vector>
 
namespace eve::pixelworld_streaming {
 
struct PixelChunkTransportConfig {
    std::uint32_t maximumInFlightTransfers = 8;
    std::uint32_t maximumChunksPerPart = 1;
    std::uint32_t maximumPartsPerTransfer = 8192;
    std::uint32_t maximumBufferedTransfers = 16;
};
 
struct PixelChunkTransferPart {
    std::uint64_t streamId = 0;
    std::uint64_t transferId = 0;
    std::uint32_t partIndex = 0;
    std::uint32_t partCount = 0;
    eve::pixelworld::PixelChunkRegion interest{};
    eve::pixelworld::PixelChunkBatch batch;
 
    friend bool operator==(const PixelChunkTransferPart&, const PixelChunkTransferPart&) = default;
};
 
struct PixelChunkTransferAck {
    std::uint64_t streamId = 0;
    std::uint64_t acknowledgedThrough = 0;
    std::uint64_t appliedRevision = 0;
};
 
struct PixelChunkAckReceipt {
    std::uint32_t transfersReleased = 0;
    std::uint32_t tombstonesReleased = 0;
    std::uint64_t acknowledgedThrough = 0;
};
 
struct PixelChunkReceiveReceipt {
    PixelChunkTransferAck ack;
    std::uint32_t transfersApplied = 0;
    std::uint32_t partsBuffered = 0;
    bool duplicate = false;
};
 
class EVENGINE_API_PLATFORM ReliablePixelChunkSender {
public:
    [[nodiscard]] static eve::Result<ReliablePixelChunkSender> create(
        std::uint64_t streamId, PixelChunkTransportConfig config = {});
 
    [[nodiscard]] eve::Result<std::vector<PixelChunkTransferPart>> capture(
        const eve::pixelworld::PixelWorld& source,
        eve::pixelworld::PixelChunkRegion interest);
 
    [[nodiscard]] std::vector<PixelChunkTransferPart> pendingParts() const;
    [[nodiscard]] eve::Result<PixelChunkAckReceipt> acknowledge(PixelChunkTransferAck ack);
    [[nodiscard]] std::size_t inFlightTransferCount() const noexcept;
    [[nodiscard]] std::size_t retainedTombstoneCount() const noexcept;
 
private:
    ReliablePixelChunkSender(std::uint64_t streamId, PixelChunkTransportConfig config);
 
    std::uint64_t streamId_ = 0;
    std::uint64_t nextTransferId_ = 1;
    std::uint64_t acknowledgedThrough_ = 0;
    std::uint64_t lastEnqueuedRevision_ = 0;
    bool captured_ = false;
    PixelChunkTransportConfig config_{};
    PixelChunkStreamCursor cursor_;
    std::map<std::uint64_t, std::vector<PixelChunkTransferPart>> inFlight_;
};
 
class EVENGINE_API_PLATFORM ReliablePixelChunkReceiver {
public:
    // Class-level dllexport instantiates every member; `buffered_` holds an
    // Assembly with a vector<unique_ptr>, so the implicit copy assignment would be
    // a hard C2280. Moves stay available (create() returns by value).
    ReliablePixelChunkReceiver(const ReliablePixelChunkReceiver&)            = delete;
    ReliablePixelChunkReceiver& operator=(const ReliablePixelChunkReceiver&) = delete;
    ReliablePixelChunkReceiver(ReliablePixelChunkReceiver&&)                 = default;
    ReliablePixelChunkReceiver& operator=(ReliablePixelChunkReceiver&&)      = default;
    [[nodiscard]] static eve::Result<ReliablePixelChunkReceiver> create(
        std::uint64_t streamId, PixelChunkTransportConfig config = {});
 
    [[nodiscard]] eve::Result<PixelChunkReceiveReceipt> receive(
        PixelChunkTransferPart part, eve::pixelworld::PixelWorld& replica);
    [[nodiscard]] std::uint64_t acknowledgedThrough() const noexcept { return expectedTransferId_ - 1; }
    [[nodiscard]] std::size_t bufferedPartCount() const noexcept;
 
private:
    struct Assembly {
        std::uint32_t partCount = 0;
        std::vector<std::unique_ptr<PixelChunkTransferPart>> parts;
    };
 
    ReliablePixelChunkReceiver(std::uint64_t streamId, PixelChunkTransportConfig config);
 
    std::uint64_t streamId_ = 0;
    std::uint64_t expectedTransferId_ = 1;
    PixelChunkTransportConfig config_{};
    std::map<std::uint64_t, Assembly> buffered_;
};
 
}  // namespace eve::pixelworld_streaming