ResourceRef.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "common/Identity.h"
#include "common/Uri.h"
 
#include <cstdint>
#include <functional>
#include <ostream>
#include <string_view>
#include <utility>
#include <variant>
 
namespace eve {
 
enum class ResourceRefKind : std::uint8_t {
    Asset,
    Uri,
    Definition,
    Object,
};
 
[[nodiscard]] constexpr std::string_view resourceRefKindName(ResourceRefKind kind) noexcept {
    switch (kind) {
        case ResourceRefKind::Asset: return "asset";
        case ResourceRefKind::Uri: return "uri";
        case ResourceRefKind::Definition: return "definition";
        case ResourceRefKind::Object: return "object";
    }
    return "unknown";
}
 
inline std::ostream& operator<<(std::ostream& stream, ResourceRefKind kind) {
    return stream << resourceRefKindName(kind);
}
 
class EVENGINE_API_FOUNDATION AssetRef {
public:
    [[nodiscard]] static Result<AssetRef> parse(std::string_view text);
 
    [[nodiscard]] static Result<AssetRef> fromId(PersistentId id);
 
    [[nodiscard]] static Result<AssetRef> fromUri(const ResourceUri& uri);
 
    [[nodiscard]] const PersistentId& id() const noexcept { return id_; }
 
    [[nodiscard]] std::string format() const;
 
    friend bool operator==(const AssetRef&, const AssetRef&) noexcept = default;
 
private:
    explicit AssetRef(PersistentId id) : id_(id) {}
 
    PersistentId id_;
};
 
class EVENGINE_API_FOUNDATION DefinitionRef {
public:
    DefinitionRef() = default;
 
    [[nodiscard]] static Result<DefinitionRef> parse(std::string_view text);
 
    [[nodiscard]] static Result<DefinitionRef> fromId(LogicalId id);
 
    [[nodiscard]] const LogicalId& id() const noexcept { return id_; }
 
    [[nodiscard]] const std::string& format() const noexcept { return id_.format(); }
 
    friend bool operator==(const DefinitionRef&, const DefinitionRef&) noexcept = default;
 
private:
    explicit DefinitionRef(LogicalId id) : id_(std::move(id)) {}
 
    LogicalId id_;
};
 
class EVENGINE_API_FOUNDATION ObjectRef {
public:
    [[nodiscard]] static Result<ObjectRef> parse(std::string_view text);
 
    [[nodiscard]] static Result<ObjectRef> fromId(PersistentId id);
 
    [[nodiscard]] const PersistentId& id() const noexcept { return id_; }
 
    [[nodiscard]] std::string format() const { return id_.format(); }
 
    friend bool operator==(const ObjectRef&, const ObjectRef&) noexcept = default;
 
private:
    explicit ObjectRef(PersistentId id) : id_(id) {}
 
    PersistentId id_;
};
 
class EVENGINE_API_FOUNDATION ResourceRef {
public:
    [[nodiscard]] static Result<ResourceRef> parse(std::string_view text);
 
    [[nodiscard]] static ResourceRef fromAsset(AssetRef value) { return ResourceRef(std::move(value)); }
 
    [[nodiscard]] static ResourceRef fromUri(ResourceUri value) { return ResourceRef(std::move(value)); }
 
    [[nodiscard]] static ResourceRef fromDefinition(DefinitionRef value) { return ResourceRef(std::move(value)); }
 
    [[nodiscard]] static ResourceRef fromObject(ObjectRef value) { return ResourceRef(std::move(value)); }
 
    [[nodiscard]] ResourceRefKind kind() const noexcept;
 
    [[nodiscard]] const AssetRef* asset() const noexcept;
 
    [[nodiscard]] const ResourceUri* uri() const noexcept;
 
    [[nodiscard]] const DefinitionRef* definition() const noexcept;
 
    [[nodiscard]] const ObjectRef* object() const noexcept;
 
    friend bool operator==(const ResourceRef&, const ResourceRef&) noexcept = default;
 
private:
    explicit ResourceRef(AssetRef value) : value_(std::move(value)) {}
    explicit ResourceRef(ResourceUri value) : value_(std::move(value)) {}
    explicit ResourceRef(DefinitionRef value) : value_(std::move(value)) {}
    explicit ResourceRef(ObjectRef value) : value_(std::move(value)) {}
 
    std::variant<AssetRef, ResourceUri, DefinitionRef, ObjectRef> value_;
};
 
}  // namespace eve
 
namespace std {
 
template <>
struct hash<eve::AssetRef> {
    std::size_t operator()(const eve::AssetRef& value) const noexcept {
        return std::hash<eve::PersistentId>{}(value.id());
    }
};
 
template <>
struct hash<eve::DefinitionRef> {
    std::size_t operator()(const eve::DefinitionRef& value) const noexcept {
        return std::hash<eve::LogicalId>{}(value.id());
    }
};
 
template <>
struct hash<eve::ObjectRef> {
    std::size_t operator()(const eve::ObjectRef& value) const noexcept {
        return std::hash<eve::PersistentId>{}(value.id());
    }
};
 
}  // namespace std