Container.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Generation.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Revision.h"
 
#include <cmath>
#include <compare>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
#include <vector>
 
namespace eve::game_event {
struct GameEvent;
}
 
namespace eve::container {
 
struct ContainerObject;
 
class ContainerId {
public:
    ContainerId() = default;
    explicit ContainerId(std::string value) : value_(std::move(value)) {}
 
    [[nodiscard]] static std::optional<ContainerId> from(std::string_view value) {
        if (value.empty()) return std::nullopt;
        return ContainerId(std::string(value));
    }
    [[nodiscard]] bool isValid() const noexcept { return !value_.empty(); }
    [[nodiscard]] const std::string& value() const noexcept { return value_; }
    friend bool                      operator==(const ContainerId&, const ContainerId&) noexcept = default;
 
private:
    std::string value_;
};
 
class MembershipId {
public:
    MembershipId() = default;
    explicit MembershipId(std::string value) : value_(std::move(value)) {}
 
    [[nodiscard]] static std::optional<MembershipId> from(std::string_view value) {
        if (value.empty()) return std::nullopt;
        return MembershipId(std::string(value));
    }
    [[nodiscard]] bool isValid() const noexcept { return !value_.empty(); }
    [[nodiscard]] const std::string& value() const noexcept { return value_; }
    friend bool                      operator==(const MembershipId&, const MembershipId&) noexcept = default;
 
private:
    std::string value_;
};
 
class Capacity {
public:
    [[nodiscard]] static constexpr Capacity fixed(std::size_t value) noexcept { return Capacity(value, false); }
    [[nodiscard]] static constexpr Capacity unlimited() noexcept { return Capacity(0, true); }
    [[nodiscard]] constexpr bool            isUnlimited() const noexcept { return unlimited_; }
    [[nodiscard]] constexpr std::size_t     value() const noexcept { return value_; }
 
private:
    constexpr Capacity(std::size_t value, bool unlimited) noexcept : value_(value), unlimited_(unlimited) {}
    std::size_t value_     = 0;
    bool        unlimited_ = false;
};
 
enum class Ordering : std::uint8_t {
    Unordered,
    Insertion,
    Stack,
    Queue,
    ExplicitSlots,
};
 
class SlotIndex {
public:
    constexpr SlotIndex() noexcept = default;
    explicit constexpr SlotIndex(std::int32_t value) noexcept : value_(value) {}
    [[nodiscard]] static constexpr SlotIndex invalid() noexcept { return SlotIndex(-1); }
    [[nodiscard]] constexpr bool             isValid() const noexcept { return value_ >= 0; }
    [[nodiscard]] constexpr std::int32_t     value() const noexcept { return value_; }
    friend constexpr bool                    operator==(const SlotIndex&, const SlotIndex&) noexcept  = default;
    friend constexpr auto                    operator<=>(const SlotIndex&, const SlotIndex&) noexcept = default;
 
private:
    std::int32_t value_ = -1;
};
 
class Filter {
public:
    using Predicate = std::function<Result<void>(const ContainerObject&)>;
 
    Filter() = default;
    explicit Filter(Predicate predicate) : predicate_(std::move(predicate)) {}
 
    [[nodiscard]] Result<void> evaluate(const struct ContainerObject& object) const {
        if (!predicate_) return Result<void>::success();
        return predicate_(object);
    }
    [[nodiscard]] bool empty() const noexcept { return !predicate_; }
 
private:
    Predicate predicate_;
};
 
struct ContainerObjectPayload {
    virtual ~ContainerObjectPayload() = default;
};
 
struct ContainerObject {
    MembershipId                                  id;
    std::string                                   type;
    std::vector<std::string>                      tags;
    std::uint32_t                                 quantity = 1;
    std::shared_ptr<const ContainerObjectPayload> payload;
};
 
struct Membership {
    MembershipId object;
    SlotIndex    slot;
    Generation   generation = Generation(1);
};
 
struct MembershipEntry {
    Membership      membership;
    ContainerObject object;
};
 
struct ContainerSnapshot {
    ContainerId                  id;
    Revision                     revision = Revision(0);
    std::vector<MembershipEntry> entries;
};
 
struct ContainerDescriptor {
    ContainerId id;
    Capacity    capacity = Capacity::unlimited();
    Ordering    ordering = Ordering::Unordered;
    Filter      filter;
};
 
enum class ContainerEventKind : std::uint8_t {
    Enter,
    Exit,
    Accepted,
    Rejected,
};
 
[[nodiscard]] inline const char* containerEventTypeName(ContainerEventKind kind) noexcept {
    switch (kind) {
        case ContainerEventKind::Enter: return "container.enter";
        case ContainerEventKind::Exit: return "container.exit";
        case ContainerEventKind::Accepted: return "container.accepted";
        case ContainerEventKind::Rejected: return "container.rejected";
    }
    return "container.rejected";
}
 
inline constexpr std::string_view containerEventSchemaName = "container:event";
 
using GameEventSink = std::function<void(const game_event::GameEvent&)>;
 
[[nodiscard]] inline EventId deterministicContainerEventId(const ContainerId& container, const MembershipId& object,
                                                           ContainerEventKind kind, std::uint64_t serial) noexcept {
    auto mix = [](std::uint64_t value, std::string_view text) noexcept {
        for (const unsigned char byte : text) {
            value ^= byte;
            value *= 1099511628211ull;
        }
        return value;
    };
    std::uint64_t first  = mix(14695981039346656037ull, container.value());
    first                = mix(first, object.value());
    first                = mix(first, std::string_view(containerEventTypeName(kind)));
    std::uint64_t second = mix(1099511628211ull ^ serial, object.value());
    second               = mix(second, container.value());
    second ^= serial + 0x9e3779b97f4a7c15ull;
 
    EventId::Bytes bytes{};
    for (std::size_t index = 0; index < sizeof(first); ++index)
        bytes[index] = static_cast<std::uint8_t>((first >> (index * 8u)) & 0xffu);
    for (std::size_t index = 0; index < sizeof(second); ++index)
        bytes[sizeof(first) + index] = static_cast<std::uint8_t>((second >> (index * 8u)) & 0xffu);
    // Mark the derived value as a conventional UUID variant/version while
    // retaining deterministic bytes.
    bytes[6] = static_cast<std::uint8_t>((bytes[6] & 0x0fu) | 0x50u);
    bytes[8] = static_cast<std::uint8_t>((bytes[8] & 0x3fu) | 0x80u);
    return EventId(bytes);
}
 
class IContainer {
public:
    class PreparedState {
    public:
        virtual ~PreparedState() = default;
 
        virtual void commit() noexcept = 0;
 
        virtual void rollback() noexcept = 0;
    };
 
    virtual ~IContainer() = default;
 
    [[nodiscard]] virtual const ContainerDescriptor& descriptor() const noexcept = 0;
    [[nodiscard]] virtual Result<ContainerSnapshot> snapshot() const = 0;
    [[nodiscard]] virtual Result<void> validateInsert(
        const ContainerObject& object, std::optional<SlotIndex> destination,
        std::optional<MembershipId> ignoredObject = std::nullopt) const = 0;
 
    [[nodiscard]] virtual Result<std::unique_ptr<PreparedState>> prepare(const ContainerSnapshot& expected,
                                                                         const ContainerSnapshot& candidate) = 0;
};
 
struct TransferEvent {
    ContainerId  source;
    ContainerId  destination;
    MembershipId object;
    SlotIndex    sourceSlot;
    SlotIndex    destinationSlot;
    Revision     sourceRevision;
    Revision     destinationRevision;
};
 
using TransferEventSink = std::function<void(const TransferEvent&)>;
 
struct TransferRequest {
    IContainer*              source      = nullptr;
    IContainer*              destination = nullptr;
    MembershipId             object;
    std::optional<SlotIndex> sourceSlot;
    std::optional<SlotIndex> destinationSlot;
    std::optional<Revision>  expectedSourceRevision;
    std::optional<Revision>  expectedDestinationRevision;
};
 
struct TransferReceipt {
    ContainerId  source;
    ContainerId  destination;
    MembershipId object;
    SlotIndex    sourceSlot;
    SlotIndex    destinationSlot;
    Revision     sourceRevision;
    Revision     destinationRevision;
};
 
class EVENGINE_API_FOUNDATION TransferService {
public:
    [[nodiscard]] static Result<TransferReceipt> transfer(const TransferRequest& request,
                                                          TransferEventSink      eventSink = {});
};
 
// ---- Strong coordinate-space zone contract --------------------------------
 
struct ScreenSpace {};
struct World2DSpace {};
struct World3DSpace {};
struct GridSpace {};
 
template <class Space>
struct Coordinate {
    float x = 0.f;
    float y = 0.f;
};
 
template <>
struct Coordinate<World3DSpace> {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
};
 
template <class Space>
struct Rectangle {
    Coordinate<Space> origin;
    float             width  = 0.f;
    float             height = 0.f;
};
 
template <class Space>
struct Circle {
    Coordinate<Space> center;
    float             radius = 0.f;
};
 
struct Box3D {
    Coordinate<World3DSpace> origin;
    float                    width  = 0.f;
    float                    height = 0.f;
    float                    depth  = 0.f;
};
 
struct Sphere3D {
    Coordinate<World3DSpace> center;
    float                    radius = 0.f;
};
 
template <class Space>
struct ZoneShapeTraits {
    using type = std::variant<Rectangle<Space>, Circle<Space>>;
};
 
template <>
struct ZoneShapeTraits<World3DSpace> {
    using type = std::variant<Box3D, Sphere3D>;
};
 
template <class Space>
using ZoneShape = typename ZoneShapeTraits<Space>::type;
 
using AcceptedCondition = Filter;
 
template <class Space>
class Zone {
public:
    [[nodiscard]] static Result<Zone> create(ContainerId id, ZoneShape<Space> shape,
                                             Capacity          capacity = Capacity::unlimited(),
                                             AcceptedCondition accepted = {}) {
        if (!id.isValid()) {
            return Result<Zone>::failure(
                Diagnostic::error(DiagnosticCode::InvalidArgument, "zone id must not be empty"));
        }
        if (!validShape(shape)) {
            return Result<Zone>::failure(
                Diagnostic::error(DiagnosticCode::InvalidArgument, "zone shape must have positive dimensions"));
        }
        return Result<Zone>::success(Zone(std::move(id), std::move(shape), capacity, std::move(accepted)));
    }
 
    [[nodiscard]] static Result<Zone> create(ZoneShape<Space> shape, Capacity capacity = Capacity::unlimited(),
                                             AcceptedCondition accepted = {}) {
        return create(ContainerId("zone:anonymous"), std::move(shape), capacity, std::move(accepted));
    }
 
    [[nodiscard]] bool isValid() const noexcept { return valid_; }
 
    [[nodiscard]] const ContainerId& id() const noexcept { return id_; }
 
    [[nodiscard]] bool hasIdentity() const noexcept { return id_.isValid(); }
 
    [[nodiscard]] bool contains(Coordinate<Space> point) const noexcept {
        return std::visit(
            [point](const auto& shape) {
                using Shape = std::decay_t<decltype(shape)>;
                if constexpr (std::is_same_v<Space, World3DSpace>) {
                    if constexpr (std::is_same_v<Shape, Box3D>) {
                        return point.x >= shape.origin.x && point.y >= shape.origin.y && point.z >= shape.origin.z &&
                               point.x <= shape.origin.x + shape.width && point.y <= shape.origin.y + shape.height &&
                               point.z <= shape.origin.z + shape.depth;
                    } else {
                        const float dx = point.x - shape.center.x;
                        const float dy = point.y - shape.center.y;
                        const float dz = point.z - shape.center.z;
                        return dx * dx + dy * dy + dz * dz <= shape.radius * shape.radius;
                    }
                } else if constexpr (std::is_same_v<Shape, Rectangle<Space>>) {
                    return point.x >= shape.origin.x && point.y >= shape.origin.y &&
                           point.x <= shape.origin.x + shape.width && point.y <= shape.origin.y + shape.height;
                } else {
                    const float dx = point.x - shape.center.x;
                    const float dy = point.y - shape.center.y;
                    return dx * dx + dy * dy <= shape.radius * shape.radius;
                }
            },
            shape_);
    }
 
    [[nodiscard]] Result<void> accepts(const ContainerObject& object) const { return accepted_.evaluate(object); }
    [[nodiscard]] const AcceptedCondition& acceptedCondition() const noexcept { return accepted_; }
    [[nodiscard]] Capacity capacity() const noexcept { return capacity_; }
    [[nodiscard]] const ZoneShape<Space>& shape() const noexcept { return shape_; }
 
private:
    Zone(ContainerId id, ZoneShape<Space> shape, Capacity capacity, AcceptedCondition accepted)
        : id_(std::move(id)),
          shape_(std::move(shape)),
          capacity_(capacity),
          accepted_(std::move(accepted)),
          valid_(true) {}
 
    [[nodiscard]] static bool validShape(const ZoneShape<Space>& shape) noexcept {
        return std::visit(
            [](const auto& value) {
                using Shape = std::decay_t<decltype(value)>;
                if constexpr (std::is_same_v<Shape, Rectangle<Space>>) {
                    return std::isfinite(value.origin.x) && std::isfinite(value.origin.y) &&
                           std::isfinite(value.width) && std::isfinite(value.height) && value.width > 0.f &&
                           value.height > 0.f;
                } else if constexpr (std::is_same_v<Shape, Box3D>) {
                    return std::isfinite(value.origin.x) && std::isfinite(value.origin.y) &&
                           std::isfinite(value.origin.z) && std::isfinite(value.width) && std::isfinite(value.height) &&
                           std::isfinite(value.depth) && value.width > 0.f && value.height > 0.f && value.depth > 0.f;
                } else if constexpr (std::is_same_v<Space, World3DSpace>) {
                    return std::isfinite(value.center.x) && std::isfinite(value.center.y) &&
                           std::isfinite(value.center.z) && std::isfinite(value.radius) && value.radius > 0.f;
                } else {
                    return std::isfinite(value.center.x) && std::isfinite(value.center.y) &&
                           std::isfinite(value.radius) && value.radius > 0.f;
                }
            },
            shape);
    }
 
    ContainerId       id_;
    ZoneShape<Space>  shape_;
    Capacity          capacity_;
    AcceptedCondition accepted_;
    bool              valid_ = false;
};
 
}  // namespace eve::container
 
namespace std {
template <>
struct hash<eve::container::ContainerId> {
    size_t operator()(const eve::container::ContainerId& value) const noexcept { return hash<string>{}(value.value()); }
};
template <>
struct hash<eve::container::MembershipId> {
    size_t operator()(const eve::container::MembershipId& value) const noexcept {
        return hash<string>{}(value.value());
    }
};
}  // namespace std