RuntimeRegistry.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "common/Result.h"
#include "common/RuntimeHandle.h"
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace eve::script {
 
template <class T>
using Owned = std::unique_ptr<T>;
template <class T>
class Borrowed {
public:
    constexpr Borrowed() noexcept = default;
    explicit constexpr Borrowed(T* value, std::uint64_t ownerEpoch = 0) noexcept
        : value_(value), ownerEpoch_(ownerEpoch) {}
    explicit constexpr Borrowed(T& value, std::uint64_t ownerEpoch = 0) noexcept
        : value_(&value), ownerEpoch_(ownerEpoch) {}
 
    [[nodiscard]] constexpr T* get() const noexcept { return value_; }
    [[nodiscard]] constexpr bool isBound() const noexcept { return value_ != nullptr; }
    [[nodiscard]] constexpr std::uint64_t ownerEpoch() const noexcept { return ownerEpoch_; }
    constexpr T* operator->() const noexcept { return value_; }
    constexpr T& operator*() const noexcept { return *value_; }
 
private:
    T*            value_      = nullptr;
    std::uint64_t ownerEpoch_ = 0;
};
 
 
template <class Tag>
struct RuntimeHandleRef {
    RuntimeHandle<Tag> handle     = RuntimeHandle<Tag>::invalid();
    std::uint64_t      ownerEpoch = 0;
 
    [[nodiscard]] constexpr bool isValid() const noexcept { return handle.isValid() && ownerEpoch != 0; }
    [[nodiscard]] constexpr std::uint64_t packed() const noexcept { return handle.packed(); }
    friend constexpr bool operator==(const RuntimeHandleRef&, const RuntimeHandleRef&) noexcept = default;
};
 
namespace detail {
 
using OwnedInstanceDestroy = void (*)(void*) noexcept;
 
template <class T>
void ownedInstanceDestroy(void* pointer) noexcept {
    delete static_cast<T*>(pointer);
}
 
struct RuntimeSlotCoordinates {
    std::uint32_t index      = 0;
    std::uint32_t generation = 0;
};
 
class RuntimeSlotStore {
public:
    explicit RuntimeSlotStore(OwnedInstanceDestroy destroy) noexcept : destroy_(destroy), ownerEpoch_(nextEpoch()) {}
 
    RuntimeSlotStore(const RuntimeSlotStore&)            = delete;
    RuntimeSlotStore& operator=(const RuntimeSlotStore&) = delete;
    // A RuntimePin holds this store's address, so relocating the store would leave that pin
    // unpinning the moved-from store while the payload lives in the destination. The store
    // must therefore stay at a fixed address for its whole lifetime.
    RuntimeSlotStore(RuntimeSlotStore&&)            = delete;
    RuntimeSlotStore& operator=(RuntimeSlotStore&&) = delete;
    EVENGINE_API ~RuntimeSlotStore();
 
    [[nodiscard]] EVENGINE_API Result<RuntimeSlotCoordinates> emplace(void* object);
 
    [[nodiscard]] EVENGINE_API void* resolve(std::uint32_t index, std::uint32_t generation,
                                             std::uint64_t ownerEpoch) const noexcept;
 
    [[nodiscard]] EVENGINE_API Result<void> erase(std::uint32_t index, std::uint32_t generation,
                                                  std::uint64_t ownerEpoch);
 
    [[nodiscard]] EVENGINE_API bool isStale(std::uint32_t index, std::uint32_t generation,
                                            std::uint64_t ownerEpoch) const noexcept;
 
    [[nodiscard]] EVENGINE_API Result<void*> pin(std::uint32_t index, std::uint32_t generation,
                                                 std::uint64_t ownerEpoch);
 
    EVENGINE_API void unpin(std::uint32_t index, std::uint64_t ownerEpoch) noexcept;
 
    EVENGINE_API void clear();
 
    template <class F>
    void forEachLive(F&& visit) {
        for (std::uint32_t index = 0; index < slots_.size(); ++index) {
            void* object = slots_[index].object;
            if (object == nullptr) continue;
            visit(index, object);
        }
    }
 
    template <class F>
    void forEachLive(F&& visit) const {
        for (std::uint32_t index = 0; index < slots_.size(); ++index) {
            const void* object = slots_[index].object;
            if (object == nullptr) continue;
            visit(index, object);
        }
    }
 
    [[nodiscard]] std::uint64_t ownerEpoch() const noexcept { return ownerEpoch_; }
 
private:
    struct Slot {
        std::uint32_t generation = 1;
        bool          retired    = false;
        bool orphaned = false;
        std::uint32_t pins   = 0;
        void*         object = nullptr;
    };
 
    [[nodiscard]] std::optional<std::uint32_t> findSlot(std::uint32_t index, std::uint32_t generation,
                                                        std::uint64_t ownerEpoch) const noexcept;
    [[nodiscard]] static bool                  coordinatesValid(std::uint32_t index, std::uint32_t generation) noexcept;
    [[nodiscard]] static std::optional<std::uint32_t> nextGeneration(std::uint32_t current) noexcept;
    [[nodiscard]] EVENGINE_API static std::uint64_t   nextEpoch() noexcept;
    void                                              destroySlot(Slot& slot) noexcept;
 
    OwnedInstanceDestroy       destroy_;
    std::uint64_t              ownerEpoch_;
    std::vector<Slot>          slots_;
    std::vector<std::uint32_t> freeSlots_;
 
    inline static std::atomic<std::uint64_t> nextEpoch_{1};
};
 
}  // namespace detail
 
template <class T, class Tag>
class RuntimeObjectRegistry;
 
template <class T, class Tag>
class RuntimePin {
public:
    using Ref = RuntimeHandleRef<Tag>;
 
    RuntimePin()                             = default;
    RuntimePin(const RuntimePin&)            = delete;
    RuntimePin& operator=(const RuntimePin&) = delete;
 
    RuntimePin(RuntimePin&& other) noexcept
        : store_(other.store_), reference_(other.reference_), object_(other.object_) {
        other.store_  = nullptr;
        other.object_ = nullptr;
    }
 
    RuntimePin& operator=(RuntimePin&& other) noexcept {
        if (this != &other) {
            release();
            store_        = other.store_;
            reference_    = other.reference_;
            object_       = other.object_;
            other.store_  = nullptr;
            other.object_ = nullptr;
        }
        return *this;
    }
 
    ~RuntimePin() { release(); }
 
    [[nodiscard]] bool isBound() const noexcept { return store_ != nullptr && object_ != nullptr; }
 
    [[nodiscard]] const Ref& reference() const noexcept { return reference_; }
 
    [[nodiscard]] T* get() const noexcept { return static_cast<T*>(object_); }
 
    [[nodiscard]] Borrowed<T> borrow() const noexcept { return Borrowed<T>(get(), reference_.ownerEpoch); }
 
    [[nodiscard]] T* operator->() const noexcept { return get(); }
 
    [[nodiscard]] T& operator*() const noexcept { return *get(); }
 
private:
    friend class RuntimeObjectRegistry<T, Tag>;
 
    RuntimePin(detail::RuntimeSlotStore* store, Ref reference, void* object) noexcept
        : store_(store), reference_(reference), object_(object) {}
 
    void release() noexcept {
        if (store_ != nullptr) store_->unpin(reference_.handle.index(), reference_.ownerEpoch);
        store_  = nullptr;
        object_ = nullptr;
    }
 
    detail::RuntimeSlotStore* store_ = nullptr;
    Ref                       reference_{};
    void*                     object_ = nullptr;
};
 
template <class T, class Tag>
class RuntimeObjectRegistry {
public:
    using Handle = RuntimeHandle<Tag>;
    using Ref    = RuntimeHandleRef<Tag>;
 
    RuntimeObjectRegistry() : store_(std::make_unique<detail::RuntimeSlotStore>(&detail::ownedInstanceDestroy<T>)) {}
    RuntimeObjectRegistry(const RuntimeObjectRegistry&)            = delete;
    RuntimeObjectRegistry& operator=(const RuntimeObjectRegistry&) = delete;
    // The store lives behind a stable heap address, so moving the registry relocates only
    // that pointer: pins issued before the move keep referencing the same store and stay
    // valid, which is why the registry may be movable while RuntimeSlotStore is not.
    RuntimeObjectRegistry(RuntimeObjectRegistry&&) noexcept            = default;
    RuntimeObjectRegistry& operator=(RuntimeObjectRegistry&&) noexcept = default;
 
    [[nodiscard]] eve::Result<Ref> emplace(Owned<T> object) {
        if (!object) {
            return eve::Result<Ref>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,
                                                                    "runtime registry cannot own a null object", {}, {},
                                                                    "runtime.registry"));
        }
        auto slot = store_->emplace(static_cast<void*>(object.get()));
        if (!slot.ok()) return eve::Result<Ref>::failure(slot.status());
        const detail::RuntimeSlotCoordinates coordinates = slot.value();
        object.release();
        return eve::Result<Ref>::success(Ref{Handle(coordinates.index, coordinates.generation), store_->ownerEpoch()});
    }
 
    [[nodiscard]] Borrowed<T> resolve(Ref ref) noexcept {
        return Borrowed<T>(
            static_cast<T*>(store_->resolve(ref.handle.index(), ref.handle.generation(), ref.ownerEpoch)),
            store_->ownerEpoch());
    }
 
    [[nodiscard]] Borrowed<const T> resolve(Ref ref) const noexcept {
        return Borrowed<const T>(
            static_cast<const T*>(store_->resolve(ref.handle.index(), ref.handle.generation(), ref.ownerEpoch)),
            store_->ownerEpoch());
    }
 
    [[nodiscard]] eve::Result<void> erase(Ref ref) {
        return store_->erase(ref.handle.index(), ref.handle.generation(), ref.ownerEpoch);
    }
 
    [[nodiscard]] eve::Result<RuntimePin<T, Tag>> pin(Ref ref) {
        auto object = store_->pin(ref.handle.index(), ref.handle.generation(), ref.ownerEpoch);
        if (!object.ok()) return eve::Result<RuntimePin<T, Tag>>::failure(object.status());
        return eve::Result<RuntimePin<T, Tag>>::success(RuntimePin<T, Tag>(store_.get(), ref, object.value()));
    }
 
    [[nodiscard]] bool isStale(Ref ref) const noexcept {
        return store_->isStale(ref.handle.index(), ref.handle.generation(), ref.ownerEpoch);
    }
 
    template <class F>
    void forEachLive(F&& visit) {
        store_->forEachLive(
            [&](std::uint32_t index, void* object) { visit(index, static_cast<T&>(*static_cast<T*>(object))); });
    }
 
    template <class F>
    void forEachLive(F&& visit) const {
        store_->forEachLive([&](std::uint32_t index, const void* object) {
            visit(index, static_cast<const T&>(*static_cast<const T*>(object)));
        });
    }
 
    void clear() { store_->clear(); }
 
    [[nodiscard]] std::uint64_t ownerEpoch() const noexcept { return store_->ownerEpoch(); }
 
private:
    std::unique_ptr<detail::RuntimeSlotStore> store_;
};
 
}  // namespace eve::script