entity.hpp

#ifndef ENTT_ENTITY_ENTITY_HPP
#define ENTT_ENTITY_ENTITY_HPP


#include <cstdint>
#include <type_traits>
#include "../config/config.h"


namespace entt {


template<typename>
struct entt_traits;


template<>
struct entt_traits<std::uint16_t> {
    using entity_type = std::uint16_t;
    using version_type = std::uint8_t;
    using difference_type = std::int32_t;

    static constexpr std::uint16_t entity_mask = 0xFFF;
    static constexpr std::uint16_t version_mask = 0xF;
    static constexpr auto entity_shift = 12;
};


template<>
struct entt_traits<std::uint32_t> {
    using entity_type = std::uint32_t;
    using version_type = std::uint16_t;
    using difference_type = std::int64_t;

    static constexpr std::uint32_t entity_mask = 0xFFFFF;
    static constexpr std::uint32_t version_mask = 0xFFF;
    static constexpr auto entity_shift = 20;
};


template<>
struct entt_traits<std::uint64_t> {
    using entity_type = std::uint64_t;
    using version_type = std::uint32_t;
    using difference_type = std::int64_t;

    static constexpr std::uint64_t entity_mask = 0xFFFFFFFF;
    static constexpr std::uint64_t version_mask = 0xFFFFFFFF;
    static constexpr auto entity_shift = 32;
};


namespace internal {


class null {
    template<typename Entity>
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;

public:
    template<typename Entity>
    constexpr operator Entity() const ENTT_NOEXCEPT {
        return Entity{traits_type<Entity>::entity_mask};
    }

    constexpr bool operator==(null) const ENTT_NOEXCEPT {
        return true;
    }

    constexpr bool operator!=(null) const ENTT_NOEXCEPT {
        return false;
    }

    template<typename Entity>
    constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
        return (to_integer(entity) & traits_type<Entity>::entity_mask) == to_integer(static_cast<Entity>(*this));
    }

    template<typename Entity>
    constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
        return !(entity == *this);
    }
};


template<typename Entity>
constexpr bool operator==(const Entity entity, null other) ENTT_NOEXCEPT {
    return other == entity;
}


template<typename Entity>
constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
    return other != entity;
}


}


constexpr auto null = internal::null{};


}


#endif // ENTT_ENTITY_ENTITY_HPP