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

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
 

src/entt/entity/registry.hpp

@@ -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), ...);
         }

test/entt/entity/handle.cpp

@@ -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());

test/entt/entity/registry.cpp

@@ -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) {