Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

registry: removed ::version/::entity (use entt_traits instead)

Browse Source
This commit is contained in:
Michele Caini
2021-08-16 23:30:14 +02:00
parent 3c4d13d8b9
commit e1fadbc9b9
4 changed files with 56 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
TODO
View File

@@ -11,7 +11,6 @@ WIP:
* make pools available (registry/view/group), review operator| for views, make views accept registry to ctor
* make view.lead() or similar available to return leading pool (useful for mt)
* dedicated entity storage, in-place O(1) release/destroy
* deprecate registry::entity, registry::version (use entt_traits)
* general purpose paged vector container
* custom allocators all over

30
src/entt/entity/registry.hpp
View File

@@ -157,24 +157,6 @@ public:
/*! @brief Poly storage type. */
using poly_storage = typename poly_storage_traits<Entity>::storage_type;
/**
* @brief Returns the identifier without the version.
* @param entity An identifier, either valid or not.
* @return The identifier without the version.
*/
[[nodiscard]] static entity_type entity(const entity_type entity) ENTT_NOEXCEPT {
return entity_traits::combine(entity_traits::to_integral(entity), {});
}
/**
* @brief Returns the version stored along with an identifier.
* @param entity An identifier, either valid or not.
* @return The version stored along with the given identifier.
*/
[[nodiscard]] static version_type version(const entity_type entity) ENTT_NOEXCEPT {
return entity_traits::to_version(entity);
}
/*! @brief Default constructor. */
basic_registry() = default;
@@ -362,7 +344,7 @@ public:
*/
[[nodiscard]] version_type current(const entity_type entity) const {
const auto pos = size_type(entity_traits::to_entity(entity));
return pos < entities.size() ? version(entities[pos]) : entity_traits::to_version(tombstone);
return entity_traits::to_version(pos < entities.size() ? entities[pos] : tombstone);
}
/**
@@ -472,7 +454,7 @@ public:
* @return The version of the recycled entity.
*/
version_type release(const entity_type entity) {
return release(entity, version(entity) + 1u);
return release(entity, entity_traits::to_version(entity) + 1u);
}
/**
@@ -504,7 +486,7 @@ public:
template<typename It>
void release(It first, It last) {
for(; first != last; ++first) {
release(*first, version(*first) + 1u);
release(*first, entity_traits::to_version(*first) + 1u);
}
}
@@ -524,7 +506,7 @@ public:
* @return The version of the recycled entity.
*/
version_type destroy(const entity_type entity) {
return destroy(entity, version(entity) + 1u);
return destroy(entity, entity_traits::to_version(entity) + 1u);
}
/**
@@ -562,7 +544,7 @@ public:
void destroy(It first, It last) {
if constexpr(is_iterator_type_v<typename basic_common_type::iterator, It>) {
for(; first != last; ++first) {
destroy(*first, version(*first) + 1u);
destroy(*first, entity_traits::to_version(*first) + 1u);
}
} else {
for(auto &&pdata: pools) {
@@ -958,7 +940,7 @@ public:
pdata.pool && (pdata.pool->clear(this), true);
}
each([this](const auto entity) { release_entity(entity, version(entity) + 1u); });
each([this](const auto entity) { release_entity(entity, entity_traits::to_version(entity) + 1u); });
} else {
(assure<Component>()->clear(this), ...);
}

5
test/entt/entity/handle.cpp
View File

@@ -1,6 +1,7 @@
#include <type_traits>
#include <utility>
#include <gtest/gtest.h>
#include <entt/entity/entity.hpp>
#include <entt/entity/handle.hpp>
#include <entt/entity/registry.hpp>
@@ -64,6 +65,8 @@ TEST(BasicHandle, Invalidation) {
}
TEST(BasicHandle, Destruction) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
const auto entity = registry.create();
entt::handle handle{registry, entity};
@@ -73,7 +76,7 @@ TEST(BasicHandle, Destruction) {
ASSERT_NE(handle.registry(), nullptr);
ASSERT_EQ(handle.entity(), entity);
handle.destroy(registry.version(entity));
handle.destroy(traits_type::to_version(entity));
ASSERT_FALSE(handle);
ASSERT_FALSE(handle.valid());

82
test/entt/entity/registry.cpp
View File

@@ -151,6 +151,8 @@ TEST(Registry, ContextAsConstRef) {
}
TEST(Registry, Functionalities) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
ASSERT_EQ(registry.size(), 0u);
@@ -243,12 +245,12 @@ TEST(Registry, Functionalities) {
ASSERT_EQ(registry.alive(), 3u);
ASSERT_FALSE(registry.empty());
ASSERT_EQ(registry.version(e2), 0u);
ASSERT_EQ(traits_type::to_version(e2), 0u);
ASSERT_EQ(registry.current(e2), 0u);
ASSERT_DEATH(registry.release(e2), "");
ASSERT_NO_FATAL_FAILURE(registry.destroy(e2));
ASSERT_DEATH(registry.destroy(e2), "");
ASSERT_EQ(registry.version(e2), 0u);
ASSERT_EQ(traits_type::to_version(e2), 0u);
ASSERT_EQ(registry.current(e2), 1u);
ASSERT_TRUE(registry.valid(e0));
@@ -363,20 +365,20 @@ TEST(Registry, Identifiers) {
entt::registry registry;
const auto pre = registry.create();
ASSERT_EQ(pre, registry.entity(pre));
ASSERT_EQ(traits_type::to_integral(pre), traits_type::to_entity(pre));
registry.release(pre);
const auto post = registry.create();
ASSERT_NE(pre, post);
ASSERT_EQ(entt::registry::entity(pre), entt::registry::entity(post));
ASSERT_NE(entt::registry::version(pre), entt::registry::version(post));
ASSERT_NE(registry.version(pre), registry.current(pre));
ASSERT_EQ(registry.version(post), registry.current(post));
ASSERT_EQ(traits_type::to_entity(pre), traits_type::to_entity(post));
ASSERT_NE(traits_type::to_version(pre), traits_type::to_version(post));
ASSERT_NE(traits_type::to_version(pre), registry.current(pre));
ASSERT_EQ(traits_type::to_version(post), registry.current(post));
const auto invalid = traits_type::combine(traits_type::to_entity(post) + 1u, {});
ASSERT_EQ(registry.version(invalid), typename traits_type::version_type{});
ASSERT_EQ(traits_type::to_version(invalid), typename traits_type::version_type{});
ASSERT_EQ(registry.current(invalid), traits_type::to_version(entt::tombstone));
}
@@ -397,6 +399,8 @@ TEST(Registry, Data) {
}
TEST(Registry, CreateManyEntitiesAtOnce) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::entity entities[3];
@@ -411,14 +415,14 @@ TEST(Registry, CreateManyEntitiesAtOnce) {
ASSERT_TRUE(registry.valid(entities[1]));
ASSERT_TRUE(registry.valid(entities[2]));
ASSERT_EQ(registry.entity(entities[0]), entt::entity{0});
ASSERT_EQ(registry.version(entities[0]), entt::registry::version_type{2});
ASSERT_EQ(traits_type::to_entity(entities[0]), 0u);
ASSERT_EQ(traits_type::to_version(entities[0]), 2u);
ASSERT_EQ(registry.entity(entities[1]), entt::entity{1});
ASSERT_EQ(registry.version(entities[1]), entt::registry::version_type{1});
ASSERT_EQ(traits_type::to_entity(entities[1]), 1u);
ASSERT_EQ(traits_type::to_version(entities[1]), 1u);
ASSERT_EQ(registry.entity(entities[2]), entt::entity{2});
ASSERT_EQ(registry.version(entities[2]), entt::registry::version_type{0});
ASSERT_EQ(traits_type::to_entity(entities[2]), 2u);
ASSERT_EQ(traits_type::to_version(entities[2]), 0u);
}
TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
@@ -447,6 +451,8 @@ TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
}
TEST(Registry, CreateWithHint) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
auto e3 = registry.create(entt::entity{3});
auto e2 = registry.create(entt::entity{3});
@@ -457,27 +463,29 @@ TEST(Registry, CreateWithHint) {
registry.release(e2);
ASSERT_EQ(registry.version(e2), entt::registry::version_type{});
ASSERT_EQ(registry.current(e2), entt::registry::version_type{1});
ASSERT_EQ(traits_type::to_version(e2), 0u);
ASSERT_EQ(registry.current(e2), 1u);
e2 = registry.create();
auto e1 = registry.create(entt::entity{2});
ASSERT_EQ(registry.entity(e2), entt::entity{2});
ASSERT_EQ(registry.version(e2), entt::registry::version_type{1});
ASSERT_EQ(traits_type::to_entity(e2), 2u);
ASSERT_EQ(traits_type::to_version(e2), 1u);
ASSERT_EQ(registry.entity(e1), entt::entity{1});
ASSERT_EQ(registry.version(e1), entt::registry::version_type{});
ASSERT_EQ(traits_type::to_entity(e1), 1u);
ASSERT_EQ(traits_type::to_version(e1), 0u);
registry.release(e1);
registry.release(e2);
auto e0 = registry.create(entt::entity{0});
ASSERT_EQ(e0, entt::entity{0});
ASSERT_EQ(registry.version(e0), entt::registry::version_type{});
ASSERT_EQ(traits_type::to_version(e0), 0u);
}
TEST(Registry, CreateClearCycle) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::entity pre{}, post{};
@@ -503,8 +511,8 @@ TEST(Registry, CreateClearCycle) {
ASSERT_FALSE(registry.valid(pre));
ASSERT_TRUE(registry.valid(post));
ASSERT_NE(registry.version(pre), registry.version(post));
ASSERT_EQ(registry.version(pre) + 1, registry.version(post));
ASSERT_NE(traits_type::to_version(pre), traits_type::to_version(post));
ASSERT_EQ(traits_type::to_version(pre) + 1, traits_type::to_version(post));
ASSERT_EQ(registry.current(pre), registry.current(post));
}
@@ -519,8 +527,8 @@ TEST(Registry, CreateDestroyReleaseCornerCase) {
registry.each([](auto) { FAIL(); });
ASSERT_EQ(registry.current(e0), entt::registry::version_type{1});
ASSERT_EQ(registry.current(e1), entt::registry::version_type{1});
ASSERT_EQ(registry.current(e0), 1u);
ASSERT_EQ(registry.current(e1), 1u);
}
TEST(Registry, DestroyVersion) {
@@ -529,16 +537,16 @@ TEST(Registry, DestroyVersion) {
const auto e0 = registry.create();
const auto e1 = registry.create();
ASSERT_EQ(registry.current(e0), entt::registry::version_type{});
ASSERT_EQ(registry.current(e1), entt::registry::version_type{});
ASSERT_EQ(registry.current(e0), 0u);
ASSERT_EQ(registry.current(e1), 0u);
registry.destroy(e0);
registry.destroy(e1, 3);
ASSERT_DEATH(registry.destroy(e0), "");
ASSERT_DEATH(registry.destroy(e1, 3), "");
ASSERT_EQ(registry.current(e0), entt::registry::version_type{1});
ASSERT_EQ(registry.current(e1), entt::registry::version_type{3});
ASSERT_EQ(registry.current(e0), 1u);
ASSERT_EQ(registry.current(e1), 3u);
}
TEST(Registry, RangeDestroy) {
@@ -648,16 +656,16 @@ TEST(Registry, ReleaseVersion) {
registry.create(std::begin(entities), std::end(entities));
ASSERT_EQ(registry.current(entities[0u]), entt::registry::version_type{});
ASSERT_EQ(registry.current(entities[1u]), entt::registry::version_type{});
ASSERT_EQ(registry.current(entities[0u]), 0u);
ASSERT_EQ(registry.current(entities[1u]), 0u);
registry.release(entities[0u]);
registry.release(entities[1u], 3);
ASSERT_DEATH(registry.release(entities[0u]), "");
ASSERT_DEATH(registry.release(entities[1u], 3), "");
ASSERT_EQ(registry.current(entities[0u]), entt::registry::version_type{1});
ASSERT_EQ(registry.current(entities[1u]), entt::registry::version_type{3});
ASSERT_EQ(registry.current(entities[0u]), 1u);
ASSERT_EQ(registry.current(entities[1u]), 3u);
}
TEST(Registry, RangeRelease) {
@@ -689,13 +697,13 @@ TEST(Registry, VersionOverflow) {
registry.release(entity);
ASSERT_NE(registry.current(entity), registry.version(entity));
ASSERT_NE(registry.current(entity), traits_type::to_version(entity));
ASSERT_NE(registry.current(entity), typename traits_type::version_type{});
registry.release(registry.create(), traits_type::to_version(entt::tombstone) - 1u);
registry.release(registry.create());
ASSERT_EQ(registry.current(entity), registry.version(entity));
ASSERT_EQ(registry.current(entity), traits_type::to_version(entity));
ASSERT_EQ(registry.current(entity), typename traits_type::version_type{});
}
@@ -1838,6 +1846,8 @@ TEST(Registry, StableEmplace) {
}
TEST(Registry, AssignEntities) {
using traits_type = entt::entt_traits<entt::entity>;
entt::registry registry;
entt::entity entities[3];
registry.create(std::begin(entities), std::end(entities));
@@ -1853,7 +1863,7 @@ TEST(Registry, AssignEntities) {
ASSERT_FALSE(other.valid(entities[1]));
ASSERT_FALSE(other.valid(entities[2]));
ASSERT_EQ(registry.create(), other.create());
ASSERT_EQ(other.entity(other.create()), entities[1]);
ASSERT_EQ(traits_type::to_entity(other.create()), traits_type::to_integral(entities[1]));
}
TEST(Registry, Visit) {