bantdit / enttx Goto Github PK

class Entity {
public:

    // ...

    auto index() const -> uint32_t { return static_cast<uint32_t>(id_ & INDEX_MASK); }
    auto version() const -> uint32_t { return static_cast<uint32_t>(id_ >> VERSION_SHIFT_VALUE); }

private:
    static auto constexpr INDEX_MASK{ 0xffffffffUL };
    static auto constexpr VERSION_SHIFT_VALUE{ 32UL };

    // ...
};

    template<size_t COUNT>
    auto createMany(std::array<Entity, COUNT>& entities, size_t count = 0) -> std::array<Entity, COUNT>&;

    template<size_t COUNT>
    auto createMany(std::array<Entity, COUNT>&& entities, size_t count = 0) -> std::array<Entity, COUNT>&&;

    auto createMany(std::vector<Entity>& entities, size_t count = 0) -> std::vector<Entity>&;

    auto createMany(std::vector<Entity>&& entities, size_t count = 0) -> std::vector<Entity>&&;

    template<class T, typename std::enable_if_t<is_container_v<std::decay_t<T>>>...>
    auto createMany(T &&entities, size_t count = 0)
    {
        static_assert(std::is_same_v<typename std::decay_t<T>::value_type, Entity>, "'entities' must contain 'Entity' instances");

        return _createMany(std::forward<T>(entities), count > 0 ? count : std::size(entities));
    }

template<class C>
constexpr bool is_iterable_v = is_iterable<C>::value;

template<class C, class = void>
struct is_container : std::false_type {};

template<class C>
struct is_container<C, std::void_t<decltype(std::size(std::declval<C>()), std::data(std::declval<C>()))>> : std::true_type {};

template<class C>
constexpr bool is_container_v = is_container<C>::value;

bool operator==(Entity const& rhs) const { return id_ == rhs.id_; }

bool operator==(Entity rhs) const { return id_ == rhs.id_; }

bool operator==(Entity const& rhs) const { return id_ == rhs.id_; }

bool operator==(Entity const& rhs) const noexcept { return id_ == rhs.id_; }

Entity()
      : id_{ std::numeric_limits<uint64_t>::max() }
    {}

class Entity {
public:
    Entity() noexcept = default;

private:
    uint64_t id_{ std::numeric_limits<uint64_t>::max() };
};

bool operator==(Entity const& rhs) const { return id_ == rhs.id_; }

bool constexpr operator==(Entity const& rhs) const { return id_ == rhs.id_; }