entity.hpp

#ifndef ENTT_ENTITY_ENTITY_HPP
#define ENTT_ENTITY_ENTITY_HPP
 
#include "../config/config.h"
#include "../core/bit.hpp"
#include "../stl/bit.hpp"
#include "../stl/concepts.hpp"
#include "../stl/cstddef.hpp"
#include "../stl/cstdint.hpp"
#include "../stl/type_traits.hpp"
#include "fwd.hpp"
 
namespace entt {

namespace internal {
 
template<typename>
struct entt_traits;
 
template<typename Type>
requires requires {
    requires stl::is_enum_v<Type>;
    typename internal::entt_traits<stl::underlying_type_t<Type>>::value_type;
}
struct entt_traits<Type>: entt_traits<stl::underlying_type_t<Type>> {
    using value_type = Type;
};
 
template<typename Type>
requires requires { typename Type::entity_type; }
struct entt_traits<Type>
    : entt_traits<typename Type::entity_type> {
    using value_type = Type;
};
 
template<>
struct entt_traits<stl::uint32_t> {
    using value_type = stl::uint32_t;
 
    using entity_type = stl::uint32_t;
    using version_type = stl::uint16_t;
 
    static constexpr entity_type entity_mask = 0xFFFFF;
    static constexpr entity_type version_mask = 0xFFF;
};
 
template<>
struct entt_traits<stl::uint64_t> {
    using value_type = stl::uint64_t;
 
    using entity_type = stl::uint64_t;
    using version_type = stl::uint32_t;
 
    static constexpr entity_type entity_mask = 0xFFFFFFFF;
    static constexpr entity_type version_mask = 0xFFFFFFFF;
};
 
} // namespace internal

template<typename Type>
concept entity_like = requires {
    typename internal::entt_traits<Type>::value_type;
};

template<typename Traits>
class basic_entt_traits {
    static constexpr auto length = stl::popcount(Traits::entity_mask);
 
public:
    using value_type = Traits::value_type;
    using entity_type = Traits::entity_type;
    using version_type = Traits::version_type;

    static constexpr entity_type entity_mask = Traits::entity_mask;
    static constexpr entity_type version_mask = Traits::version_mask;

    [[nodiscard]] static constexpr entity_type to_integral(const value_type value) noexcept {
        return static_cast<entity_type>(value);
    }

    [[nodiscard]] static constexpr entity_type to_entity(const value_type value) noexcept {
        static_assert(Traits::entity_mask && ((Traits::entity_mask & (Traits::entity_mask + 1)) == 0), "Invalid entity mask");
        return (to_integral(value) & entity_mask);
    }

    [[nodiscard]] static constexpr version_type to_version(const value_type value) noexcept {
        if constexpr(Traits::version_mask == 0u) {
            return version_type{};
        } else {
            static_assert((Traits::version_mask & (Traits::version_mask + 1)) == 0, "Invalid version mask");
            return (static_cast<version_type>(to_integral(value) >> length) & version_mask);
        }
    }

    [[nodiscard]] static constexpr value_type next(const value_type value) noexcept {
        const auto vers = to_version(value) + 1;
        return construct(to_integral(value), static_cast<version_type>(vers + (vers == version_mask)));
    }

    [[nodiscard]] static constexpr value_type construct(const entity_type entity, const version_type version) noexcept {
        if constexpr(Traits::version_mask == 0u) {
            return value_type{entity & entity_mask};
        } else {
            return value_type{(entity & entity_mask) | (static_cast<entity_type>(version & version_mask) << length)};
        }
    }

    [[nodiscard]] static constexpr value_type combine(const entity_type lhs, const entity_type rhs) noexcept {
        if constexpr(Traits::version_mask == 0u) {
            return value_type{lhs & entity_mask};
        } else {
            return value_type{(lhs & entity_mask) | (rhs & (version_mask << length))};
        }
    }
};

template<entity_like Type>
struct entt_traits: basic_entt_traits<internal::entt_traits<Type>> {
    using base_type = basic_entt_traits<internal::entt_traits<Type>>;
    static constexpr stl::size_t page_size = ENTT_SPARSE_PAGE;
};

template<typename Entity>
[[nodiscard]] constexpr entt_traits<Entity>::entity_type to_integral(const Entity value) noexcept {
    return entt_traits<Entity>::to_integral(value);
}

template<typename Entity>
[[nodiscard]] constexpr entt_traits<Entity>::entity_type to_entity(const Entity value) noexcept {
    return entt_traits<Entity>::to_entity(value);
}

template<typename Entity>
[[nodiscard]] constexpr entt_traits<Entity>::version_type to_version(const Entity value) noexcept {
    return entt_traits<Entity>::to_version(value);
}

struct null_t {
    template<entity_like Entity>
    [[nodiscard]] constexpr operator Entity() const noexcept {
        using traits_type = entt_traits<Entity>;
        return traits_type::construct(traits_type::entity_mask, traits_type::version_mask);
    }

    [[nodiscard]] constexpr bool operator==([[maybe_unused]] const null_t other) const noexcept {
        return true;
    }

    template<entity_like Entity>
    [[nodiscard]] constexpr bool operator==(const Entity entity) const noexcept {
        using traits_type = entt_traits<Entity>;
        return traits_type::to_entity(entity) == traits_type::to_entity(*this);
    }
};

struct tombstone_t {
    template<entity_like Entity>
    [[nodiscard]] constexpr operator Entity() const noexcept {
        using traits_type = entt_traits<Entity>;
        return traits_type::construct(traits_type::entity_mask, traits_type::version_mask);
    }

    [[nodiscard]] constexpr bool operator==([[maybe_unused]] const tombstone_t other) const noexcept {
        return true;
    }

    template<entity_like Entity>
    [[nodiscard]] constexpr bool operator==(const Entity entity) const noexcept {
        using traits_type = entt_traits<Entity>;
 
        if constexpr(traits_type::version_mask == 0u) {
            return false;
        } else {
            return (traits_type::to_version(entity) == traits_type::to_version(*this));
        }
    }
};

inline constexpr null_t null{};

inline constexpr tombstone_t tombstone{};
 
} // namespace entt
 
#endif