entity_id.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
 
#include <cstdint>
#include <limits>
 
namespace pixelbullet
{
class EntityId
{
public:
    using ValueType = uint32_t;
 
    static constexpr uint32_t index_bits = 24;
    static constexpr uint32_t version_bits = 8;
    static constexpr ValueType IndexMask = (1u << index_bits) - 1;
    static constexpr ValueType VersionMask = (1u << version_bits) - 1;
 
    constexpr EntityId() noexcept
        : value_(Invalid().value_)
    {
    }
    constexpr EntityId(uint32_t index, uint32_t version) noexcept
        : value_((version << index_bits) | (index & IndexMask))
    {
    }
 
    static constexpr EntityId Invalid() noexcept
    {
        return EntityId(std::numeric_limits<ValueType>::max());
    }
 
    static constexpr EntityId FromRaw(ValueType raw) noexcept
    {
        return EntityId(raw);
    }
 
    [[nodiscard]] constexpr uint32_t Index() const noexcept
    {
        return value_ & IndexMask;
    }
 
    [[nodiscard]] constexpr uint32_t Version() const noexcept
    {
        return (value_ >> index_bits) & VersionMask;
    }
 
    [[nodiscard]] constexpr ValueType Raw() const noexcept
    {
        return value_;
    }
 
    constexpr bool operator==(const EntityId& other) const noexcept = default;
    constexpr bool operator!=(const EntityId& other) const noexcept = default;
 
    constexpr explicit operator bool() const noexcept
    {
        return value_ != Invalid().value_;
    }
 
private:
    explicit constexpr EntityId(ValueType raw) noexcept
        : value_(raw)
    {
    }
    ValueType value_;
};
 
inline Node& operator<<(Node& node, const EntityId& entityId)
{
    return node << entityId.Raw();
}
 
inline const Node& operator>>(const Node& node, EntityId& entityId)
{
    uint32_t raw = static_cast<uint32_t>(std::stoul(node.GetValue()));
    entityId = EntityId::FromRaw(raw);
    return node;
}
} // namespace pixelbullet