Identity.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
 
#include <array>
#include <chrono>
#include <compare>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <utility>
 
namespace eve {
 
namespace detail {
 
struct PersistentIdTag {};
struct ContentIdTag {};
struct AssetGuidTag {};
struct DocumentIdTag {};
struct SceneObjectIdTag {};
struct ArtifactIdTag {};
struct EventIdTag {};
struct CommandIdTag {};
struct TransactionIdTag {};
struct OperationIdTag {};
struct EffectIdTag {};
 
using UuidBytes = std::array<std::uint8_t, 16>;
 
[[nodiscard]] EVENGINE_API std::optional<UuidBytes> parseUuidText(std::string_view text) noexcept;
 
[[nodiscard]] EVENGINE_API std::string formatUuidBytes(const UuidBytes& bytes);
 
[[nodiscard]] EVENGINE_API UuidBytes childUuidBytes(const UuidBytes& parent, std::string_view role) noexcept;
 
class UuidIdState {
public:
    EVENGINE_API void assign(std::string_view text);
 
    [[nodiscard]] EVENGINE_API static UuidBytes projectLegacy(std::string_view text) noexcept;
 
    std::string spelling;
    UuidBytes   uuid{};
    bool        canonical = false;
};
 
template <typename Tag>
class Id128 {
public:
    using Bytes = std::array<std::uint8_t, 16>;
 
    constexpr Id128() noexcept = default;
 
    explicit constexpr Id128(Bytes bytes) noexcept : bytes_(bytes) {}
 
    template <typename OtherTag>
    [[nodiscard]] static constexpr Id128 fromUuid(const Id128<OtherTag>& value) noexcept {
        return Id128(value.bytes());
    }
 
    [[nodiscard]] static constexpr Id128 nil() noexcept { return {}; }
 
    [[nodiscard]] static std::optional<Id128> parse(std::string_view text) noexcept {
        if (const auto bytes = parseUuidText(text)) return Id128(*bytes);
        return std::nullopt;
    }
 
    [[nodiscard]] static std::optional<Id128> fromBytes(std::span<const std::uint8_t> bytes) noexcept {
        if (bytes.size() != 16) return std::nullopt;
        Bytes result{};
        for (std::size_t i = 0; i < result.size(); ++i) result[i] = bytes[i];
        return Id128(result);
    }
 
    [[nodiscard]] std::string format() const { return formatUuidBytes(bytes_); }
 
    [[nodiscard]] constexpr bool isNil() const noexcept {
        for (const auto byte : bytes_) {
            if (byte != 0) return false;
        }
        return true;
    }
 
    [[nodiscard]] Id128 child(std::string_view role) const noexcept {
        if (isNil() || role.empty()) return Id128::nil();
        return Id128(childUuidBytes(bytes_, role));
    }
 
    [[nodiscard]] constexpr Bytes bytes() const noexcept { return bytes_; }
 
    [[nodiscard]] constexpr std::uint64_t hash() const noexcept {
        std::uint64_t result = 14695981039346656037ull;
        for (const auto byte : bytes_) {
            result ^= byte;
            result *= 1099511628211ull;
        }
        return result;
    }
 
    friend constexpr bool operator==(const Id128&, const Id128&) noexcept = default;
 
    friend constexpr auto operator<=>(const Id128& lhs, const Id128& rhs) noexcept { return lhs.bytes_ <=> rhs.bytes_; }
 
private:
    [[nodiscard]] static constexpr std::optional<std::uint8_t> hexValue(char value) noexcept {
        if (value >= '0' && value <= '9') return static_cast<std::uint8_t>(value - '0');
        if (value >= 'a' && value <= 'f') return static_cast<std::uint8_t>(value - 'a' + 10);
        if (value >= 'A' && value <= 'F') return static_cast<std::uint8_t>(value - 'A' + 10);
        return std::nullopt;
    }
 
    Bytes bytes_{};
};
 
}  // namespace detail
 
template <typename Tag>
using StrongUuid = detail::Id128<Tag>;
 
using PersistentId = StrongUuid<detail::PersistentIdTag>;
 
using ContentId = StrongUuid<detail::ContentIdTag>;
 
using AssetGuid = StrongUuid<detail::AssetGuidTag>;
 
using DocumentId = StrongUuid<detail::DocumentIdTag>;
 
using SceneObjectId = StrongUuid<detail::SceneObjectIdTag>;
 
using ArtifactId = StrongUuid<detail::ArtifactIdTag>;
 
using EventId = StrongUuid<detail::EventIdTag>;
 
using CommandId = StrongUuid<detail::CommandIdTag>;
 
using TransactionId = StrongUuid<detail::TransactionIdTag>;
 
using OperationId = StrongUuid<detail::OperationIdTag>;
 
using EffectId = StrongUuid<detail::EffectIdTag>;
 
template <typename Tag>
class UuidIdAdapter {
public:
    using Uuid  = StrongUuid<Tag>;
    using Bytes = typename Uuid::Bytes;
 
    UuidIdAdapter() = default;
 
    explicit UuidIdAdapter(const char* value) : UuidIdAdapter(std::string_view(value ? value : "")) {}
 
    explicit UuidIdAdapter(std::string value) : UuidIdAdapter(std::string_view(value)) {}
 
    explicit UuidIdAdapter(std::string_view value) { state_.assign(value); }
 
    [[nodiscard]] static std::optional<UuidIdAdapter> parse(std::string_view value) {
        if (value.empty()) return std::nullopt;
        return UuidIdAdapter(value);
    }
 
    [[nodiscard]] static UuidIdAdapter fromUuid(Uuid value) {
        UuidIdAdapter result;
        result.state_.uuid      = value.bytes();
        result.state_.spelling  = value.format();
        result.state_.canonical = true;
        return result;
    }
 
    [[nodiscard]] static UuidIdAdapter fromLegacy(std::string value) {
        if (value.empty()) return {};
        UuidIdAdapter result;
        result.state_.uuid      = detail::UuidIdState::projectLegacy(value);
        result.state_.spelling  = std::move(value);
        result.state_.canonical = false;
        return result;
    }
 
    [[nodiscard]] const std::string& value() const noexcept { return state_.spelling; }
 
    [[nodiscard]] const std::string& format() const noexcept { return state_.spelling; }
 
    [[nodiscard]] Uuid uuid() const noexcept { return Uuid(state_.uuid); }
 
    [[nodiscard]] std::string canonicalFormat() const { return detail::formatUuidBytes(state_.uuid); }
 
    [[nodiscard]] bool empty() const noexcept { return state_.spelling.empty(); }
 
    [[nodiscard]] bool isNil() const noexcept { return state_.spelling.empty() || Uuid(state_.uuid).isNil(); }
 
    [[nodiscard]] bool isCanonicalUuid() const noexcept { return state_.canonical; }
 
    [[nodiscard]] std::uint64_t hash() const noexcept { return Uuid(state_.uuid).hash(); }
 
    explicit operator bool() const noexcept { return !empty(); }
 
    friend bool operator==(const UuidIdAdapter& lhs, const UuidIdAdapter& rhs) noexcept {
        return lhs.state_.uuid == rhs.state_.uuid;
    }
 
    friend auto operator<=>(const UuidIdAdapter& lhs, const UuidIdAdapter& rhs) noexcept {
        return lhs.state_.uuid <=> rhs.state_.uuid;
    }
 
private:
    detail::UuidIdState state_;
};
 
class EVENGINE_API_FOUNDATION LogicalId {
public:
    LogicalId() = default;
 
    [[nodiscard]] static std::optional<LogicalId> parse(std::string_view text);
 
    [[nodiscard]] static std::optional<LogicalId> fromParts(std::string_view namespaceName, std::string_view name);
 
    [[nodiscard]] bool isValid() const noexcept { return !value_.empty(); }
 
    [[nodiscard]] const std::string& format() const noexcept { return value_; }
 
    [[nodiscard]] std::string_view namespaceName() const noexcept;
 
    [[nodiscard]] std::string_view name() const noexcept;
 
    [[nodiscard]] std::uint64_t hash() const noexcept;
 
    friend bool operator==(const LogicalId&, const LogicalId&) noexcept = default;
 
private:
    explicit LogicalId(std::string value) : value_(std::move(value)) {}
 
    std::string value_;
};
 
using UuidEntropySource = std::function<bool(std::span<std::uint8_t> bytes)>;
 
using UuidClock = std::function<std::chrono::system_clock::time_point()>;
 
class EVENGINE_API_FOUNDATION UuidV7Generator {
public:
    explicit UuidV7Generator(UuidEntropySource entropy, UuidClock clock = {});
 
    [[nodiscard]] std::optional<PersistentId> generate() const;
 
    [[nodiscard]] std::optional<PersistentId> generate(std::chrono::system_clock::time_point timestamp) const;
 
private:
    UuidEntropySource entropy_;
    UuidClock         clock_;
};
 
[[nodiscard]] EVENGINE_API_FOUNDATION std::optional<PersistentId> generateUuidV7(
    std::chrono::system_clock::time_point timestamp, const UuidEntropySource& entropy);
 
}  // namespace eve
 
namespace std {
 
template <typename Tag>
struct hash<eve::detail::Id128<Tag>> {
    std::size_t operator()(const eve::detail::Id128<Tag>& value) const noexcept {
        return static_cast<std::size_t>(value.hash());
    }
};
 
template <typename Tag>
struct hash<eve::UuidIdAdapter<Tag>> {
    std::size_t operator()(const eve::UuidIdAdapter<Tag>& value) const noexcept {
        return static_cast<std::size_t>(value.hash());
    }
};
 
template <>
struct hash<eve::LogicalId> {
    std::size_t operator()(const eve::LogicalId& value) const noexcept {
        return static_cast<std::size_t>(value.hash());
    }
};
 
}  // namespace std