entity_id.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/node_reader.h"
 
#include <cstdint>
#include <limits>
 
namespace pixelbullet
{
class EntityId
{
public:
    using ValueType = std::uint64_t;
 
    static constexpr uint32_t index_bits = 32;
    static constexpr uint32_t generation_bits = 32;
    static constexpr ValueType IndexMask = (ValueType{ 1 } << index_bits) - 1;
    static constexpr ValueType GenerationMask = (ValueType{ 1 } << generation_bits) - 1;
 
    constexpr EntityId() noexcept
        : value_(Invalid().value_)
    {
    }
    constexpr EntityId(uint32_t index, uint32_t generation) noexcept
        : value_((static_cast<ValueType>(generation) << index_bits) | (static_cast<ValueType>(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 static_cast<uint32_t>(value_ & IndexMask);
    }
 
    [[nodiscard]] constexpr uint32_t Generation() const noexcept
    {
        return static_cast<uint32_t>((value_ >> index_bits) & GenerationMask);
    }
 
    [[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)
{
    EntityId::ValueType raw = 0;
    node >> raw;
    entityId = EntityId::FromRaw(raw);
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, EntityId& entityId, serialization::NodeReader& reader)
{
    EntityId::ValueType raw = 0;
    if (!serialization::TryReadNode(node, raw, reader))
    {
        return false;
    }
    entityId = EntityId::FromRaw(raw);
    return true;
}
} // namespace pixelbullet