Id.hpp

Go to the documentation of this file.

#pragma once
 
#include "EntityToIDString.hpp"
#include <entt/entt.hpp>
#include <fmt/format.h>
 
namespace Engine {

template <typename TDerived, typename TValue> struct BasicId {
    TValue value;

    static constexpr TDerived Null(void);

    constexpr bool IsNull(void) const;
 
  private:
    constexpr explicit(false) BasicId(TValue value_ = TDerived::NullValue());
    friend TDerived;
};

struct Id : public BasicId<Id, entt::id_type> {
    using ValueType = entt::id_type;

    constexpr Id(ValueType value_ = NullValue());

    constexpr operator ValueType() const;

    static constexpr ValueType NullValue(void);

    static constexpr Id Null(void);
};
 
static_assert(sizeof(Id) == sizeof(Id::ValueType), "Id size must be equal to entt::id_type size");

struct StringId : public BasicId<StringId, entt::hashed_string> {
    using ValueType = entt::hashed_string;

    constexpr StringId(ValueType v = NullValue());

    static constexpr ValueType NullValue();

    static constexpr StringId Null();
};

static_assert(sizeof(StringId) == sizeof(StringId::ValueType),
              "StringId size must be equal to entt::hashed_string size");
} // namespace Engine

template <> struct entt::entt_traits<Engine::Id> : entt::entt_traits<entt::id_type> {
    using value_type = Engine::Id;
};

template <> struct fmt::formatter<Engine::Id> : fmt::formatter<entt::id_type> {
    template <typename FormatContext> auto format(const Engine::Id &id, FormatContext &context) const;
};

template <> struct fmt::formatter<Engine::StringId> : fmt::formatter<std::string_view> {
    template <typename FormatContext> auto format(const Engine::StringId &id, FormatContext &context) const;
};
 
#include "Id.ipp"