diff --git a/TODO b/TODO index 7681b4fb3..fd57ee4cb 100644 --- a/TODO +++ b/TODO @@ -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 diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp index f9dcf09b3..06891f3fc 100644 --- a/src/entt/entity/registry.hpp +++ b/src/entt/entity/registry.hpp @@ -157,24 +157,6 @@ public: /*! @brief Poly storage type. */ using poly_storage = typename poly_storage_traits::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 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) { 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()->clear(this), ...); } diff --git a/test/entt/entity/handle.cpp b/test/entt/entity/handle.cpp index 3b5093bbd..2664fada7 100644 --- a/test/entt/entity/handle.cpp +++ b/test/entt/entity/handle.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -64,6 +65,8 @@ TEST(BasicHandle, Invalidation) { } TEST(BasicHandle, Destruction) { + using traits_type = entt::entt_traits; + 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()); diff --git a/test/entt/entity/registry.cpp b/test/entt/entity/registry.cpp index 08393b5e8..bb1c7764f 100644 --- a/test/entt/entity/registry.cpp +++ b/test/entt/entity/registry.cpp @@ -151,6 +151,8 @@ TEST(Registry, ContextAsConstRef) { } TEST(Registry, Functionalities) { + using traits_type = entt::entt_traits; + 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::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::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::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::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) {