RuntimeHandle.h

浏览该文件的文档.

#pragma once
 
#include <compare>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <limits>
#include <optional>
 
namespace eve {
 
namespace detail {
 
struct HandleCoordinates {
    using index_type = std::uint32_t;
    using generation_type = std::uint32_t;
 
    static constexpr index_type invalidIndex = std::numeric_limits<index_type>::max();
    static constexpr generation_type invalidGeneration = 0;
 
    index_type      index      = invalidIndex;
    generation_type generation = invalidGeneration;
 
    [[nodiscard]] constexpr bool isValid() const noexcept {
        return index != invalidIndex && generation != invalidGeneration;
    }
 
    [[nodiscard]] constexpr bool isInvalid() const noexcept { return !isValid(); }
 
    [[nodiscard]] static constexpr std::optional<generation_type> nextGeneration(generation_type current) noexcept {
        if (current == std::numeric_limits<generation_type>::max()) return std::nullopt;
        return static_cast<generation_type>(current + 1u);
    }
 
    [[nodiscard]] constexpr std::optional<generation_type> bumpedGeneration() const noexcept {
        if (index == invalidIndex) return std::nullopt;
        return nextGeneration(generation);
    }
 
    [[nodiscard]] constexpr std::uint64_t packed() const noexcept {
        return (static_cast<std::uint64_t>(generation) << 32u) | static_cast<std::uint64_t>(index);
    }
 
    [[nodiscard]] static constexpr HandleCoordinates fromPacked(std::uint64_t value) noexcept {
        return HandleCoordinates{static_cast<index_type>(value & 0xffffffffull),
                                 static_cast<generation_type>(value >> 32u)};
    }
 
    friend constexpr bool operator==(const HandleCoordinates&, const HandleCoordinates&) noexcept  = default;
    friend constexpr auto operator<=>(const HandleCoordinates&, const HandleCoordinates&) noexcept = default;
};
 
}  // namespace detail
 
template <typename Tag>
class RuntimeHandle {
public:
    using index_type = detail::HandleCoordinates::index_type;
    using generation_type = detail::HandleCoordinates::generation_type;
 
    static constexpr index_type invalidIndex = detail::HandleCoordinates::invalidIndex;
    static constexpr generation_type invalidGeneration = detail::HandleCoordinates::invalidGeneration;
 
    constexpr RuntimeHandle() noexcept = default;
 
    explicit constexpr RuntimeHandle(index_type index, generation_type generation) noexcept
        : coordinates_{index, generation} {}
 
    [[nodiscard]] static constexpr RuntimeHandle invalid() noexcept { return {}; }
 
    [[nodiscard]] constexpr bool isValid() const noexcept { return coordinates_.isValid(); }
 
    [[nodiscard]] constexpr bool isInvalid() const noexcept { return coordinates_.isInvalid(); }
 
    [[nodiscard]] constexpr index_type index() const noexcept { return coordinates_.index; }
 
    [[nodiscard]] constexpr generation_type generation() const noexcept { return coordinates_.generation; }
 
    [[nodiscard]] static constexpr std::optional<generation_type> nextGeneration(generation_type current) noexcept {
        return detail::HandleCoordinates::nextGeneration(current);
    }
 
    [[nodiscard]] constexpr std::optional<RuntimeHandle> nextGeneration() const noexcept {
        const auto next = coordinates_.bumpedGeneration();
        if (!next) return std::nullopt;
        return RuntimeHandle(coordinates_.index, *next);
    }
 
    [[nodiscard]] constexpr std::uint64_t packed() const noexcept { return coordinates_.packed(); }
 
    [[nodiscard]] static constexpr RuntimeHandle fromPacked(std::uint64_t value) noexcept {
        const auto coordinates = detail::HandleCoordinates::fromPacked(value);
        return RuntimeHandle(coordinates.index, coordinates.generation);
    }
 
    friend constexpr bool operator==(const RuntimeHandle& left, const RuntimeHandle& right) noexcept {
        return left.coordinates_ == right.coordinates_;
    }
    friend constexpr auto operator<=>(const RuntimeHandle& left, const RuntimeHandle& right) noexcept {
        return left.coordinates_ <=> right.coordinates_;
    }
 
private:
    detail::HandleCoordinates coordinates_;
};
 
}  // namespace eve
 
namespace std {
 
template <typename Tag>
struct hash<eve::RuntimeHandle<Tag>> {
    std::size_t operator()(const eve::RuntimeHandle<Tag>& handle) const noexcept {
        return std::hash<std::uint64_t>{}(handle.packed());
    }
};
 
}  // namespace std