registry: removed ::size<T>(), use ::view<T>().size() or ::storage<T>().size() instead

src/entt/entity/registry.hpp

@@ -212,16 +212,6 @@ public:
         return assure<Component>(id);
     }
 
-    /**
-     * @brief Returns the number of existing components of the given type.
-     * @tparam Component Type of component of which to return the size.
-     * @return Number of existing components of the given type.
-     */
-    template<typename Component>
-    [[nodiscard]] size_type size() const {
-        return assure<std::remove_const_t<Component>>().size();
-    }
-
     /**
      * @brief Returns the number of entities created so far.
      * @return Number of entities created so far.

test/entt/entity/helper.cpp

@@ -60,10 +60,11 @@ TEST(Helper, ToEntity) {
     ASSERT_EQ(entt::to_entity(registry, value), null);
 
     const auto entity = registry.create();
-    registry.emplace<int>(entity);
+    auto &&storage = registry.storage<int>();
+    storage.emplace(entity);
 
-    while(registry.size<int>() < (ENTT_PACKED_PAGE - 1u)) {
-        registry.emplace<int>(registry.create(), value);
+    while(storage.size() < (ENTT_PACKED_PAGE - 1u)) {
+        storage.emplace(registry.create(), value);
     }
 
     const auto other = registry.create();
@@ -98,10 +99,11 @@ TEST(Helper, ToEntityStableType) {
     ASSERT_EQ(entt::to_entity(registry, value), null);
 
     const auto entity = registry.create();
+    auto &&storage = registry.storage<stable_type>();
     registry.emplace<stable_type>(entity);
 
-    while(registry.size<stable_type>() < (ENTT_PACKED_PAGE - 2u)) {
-        registry.emplace<stable_type>(registry.create(), value);
+    while(storage.size() < (ENTT_PACKED_PAGE - 2u)) {
+        storage.emplace(registry.create(), value);
     }
 
     const auto other = registry.create();

test/entt/entity/registry.cpp

@@ -163,11 +163,11 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.size(), 0u);
     ASSERT_EQ(registry.alive(), 0u);
     ASSERT_NO_FATAL_FAILURE(registry.reserve(42));
+    ASSERT_EQ(registry.capacity(), 42u);
     ASSERT_TRUE(registry.empty());
 
-    ASSERT_EQ(registry.capacity(), 42u);
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<const char>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
     ASSERT_TRUE((registry.empty<int, const char>()));
 
     const auto e0 = registry.create();
@@ -179,8 +179,8 @@ TEST(Registry, Functionalities) {
     ASSERT_TRUE(registry.all_of<>(e0));
     ASSERT_FALSE(registry.any_of<>(e1));
 
-    ASSERT_EQ(registry.size<const int>(), 1u);
-    ASSERT_EQ(registry.size<char>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<char>().size(), 1u);
     ASSERT_FALSE(registry.empty<const int>());
     ASSERT_FALSE(registry.empty<char>());
 
@@ -272,8 +272,8 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.get_or_emplace<int>(e3, 3), 3);
     ASSERT_EQ(registry.get_or_emplace<char>(e3, 'c'), 'c');
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<const char>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<char>().size(), 1u);
     ASSERT_FALSE(registry.empty<int>());
     ASSERT_FALSE(registry.empty<const char>());
     ASSERT_TRUE((registry.all_of<int, char>(e3)));
@@ -282,15 +282,15 @@ TEST(Registry, Functionalities) {
 
     ASSERT_NO_FATAL_FAILURE(registry.clear<int>());
 
-    ASSERT_EQ(registry.size<const int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 1u);
     ASSERT_TRUE(registry.empty<const int>());
     ASSERT_FALSE(registry.empty<char>());
 
     ASSERT_NO_FATAL_FAILURE(registry.clear());
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<const char>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
     ASSERT_TRUE((registry.empty<const int, char>()));
 
     const auto e4 = registry.create();
@@ -301,8 +301,8 @@ TEST(Registry, Functionalities) {
     ASSERT_EQ(registry.remove<int>(e4), 1u);
     ASSERT_EQ(registry.remove<int>(e5), 0u);
 
-    ASSERT_EQ(registry.size<const int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
     ASSERT_TRUE(registry.empty<int>());
 }
 
@@ -571,9 +571,9 @@ TEST(Registry, RangeDestroy) {
     ASSERT_FALSE(registry.valid(entities[1u]));
     ASSERT_TRUE(registry.valid(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 0u);
 
     registry.destroy(iview.begin(), iview.end());
 
@@ -582,9 +582,9 @@ TEST(Registry, RangeDestroy) {
     ASSERT_EQ(iview.size(), 0u);
     ASSERT_EQ(icview.size_hint(), 0u);
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 0u);
 
     registry.create(std::begin(entities), std::end(entities));
     registry.insert<int>(std::begin(entities), std::end(entities));
@@ -592,14 +592,14 @@ TEST(Registry, RangeDestroy) {
     ASSERT_TRUE(registry.valid(entities[0u]));
     ASSERT_TRUE(registry.valid(entities[1u]));
     ASSERT_TRUE(registry.valid(entities[2u]));
-    ASSERT_EQ(registry.size<int>(), 3u);
+    ASSERT_EQ(registry.storage<int>().size(), 3u);
 
     registry.destroy(std::begin(entities), std::end(entities));
 
     ASSERT_FALSE(registry.valid(entities[0u]));
     ASSERT_FALSE(registry.valid(entities[1u]));
     ASSERT_FALSE(registry.valid(entities[2u]));
-    ASSERT_EQ(registry.size<int>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
 }
 
 TEST(Registry, StableDestroy) {
@@ -629,9 +629,9 @@ TEST(Registry, StableDestroy) {
     ASSERT_FALSE(registry.valid(entities[1u]));
     ASSERT_TRUE(registry.valid(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 0u);
 
     registry.destroy(iview.begin(), iview.end());
 
@@ -639,9 +639,9 @@ TEST(Registry, StableDestroy) {
     ASSERT_EQ(iview.size(), 0u);
     ASSERT_EQ(icview.size_hint(), 0u);
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 0u);
 }
 
 TEST(Registry, ReleaseVersion) {
@@ -1435,9 +1435,9 @@ TEST(Registry, Erase) {
     ASSERT_FALSE(registry.all_of<int>(entities[1u]));
     ASSERT_TRUE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     registry.erase<int>(iview.begin(), iview.end());
 
@@ -1447,21 +1447,21 @@ TEST(Registry, Erase) {
     ASSERT_FALSE(registry.any_of<int>(entities[2u]));
     ASSERT_NO_FATAL_FAILURE(registry.erase<int>(iview.rbegin(), iview.rend()));
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     registry.insert<int>(std::begin(entities), std::end(entities));
     registry.insert<char>(std::begin(entities), std::end(entities));
 
-    ASSERT_EQ(registry.size<int>(), 3u);
-    ASSERT_EQ(registry.size<char>(), 3u);
+    ASSERT_EQ(registry.storage<int>().size(), 3u);
+    ASSERT_EQ(registry.storage<char>().size(), 3u);
 
     registry.erase<int, char>(std::begin(entities), std::end(entities));
 
     ASSERT_DEATH((registry.erase<int, char>(std::begin(entities), std::end(entities))), "");
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
 
     ASSERT_FALSE(registry.orphan(entities[0u]));
     ASSERT_TRUE(registry.orphan(entities[1u]));
@@ -1497,9 +1497,9 @@ TEST(Registry, StableErase) {
     ASSERT_FALSE(registry.all_of<int>(entities[1u]));
     ASSERT_TRUE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     registry.erase<int>(iview.begin(), iview.end());
 
@@ -1508,9 +1508,9 @@ TEST(Registry, StableErase) {
 
     ASSERT_FALSE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
 TEST(Registry, Remove) {
@@ -1543,9 +1543,9 @@ TEST(Registry, Remove) {
     ASSERT_FALSE(registry.all_of<int>(entities[1u]));
     ASSERT_TRUE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     ASSERT_EQ((registry.remove<int>(iview.begin(), iview.end())), 1u);
 
@@ -1555,21 +1555,21 @@ TEST(Registry, Remove) {
     ASSERT_FALSE(registry.any_of<int>(entities[2u]));
     ASSERT_EQ(registry.remove<int>(iview.begin(), iview.end()), 0u);
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     registry.insert<int>(std::begin(entities), std::end(entities));
     registry.insert<char>(std::begin(entities), std::end(entities));
 
-    ASSERT_EQ(registry.size<int>(), 3u);
-    ASSERT_EQ(registry.size<char>(), 3u);
+    ASSERT_EQ(registry.storage<int>().size(), 3u);
+    ASSERT_EQ(registry.storage<char>().size(), 3u);
 
     registry.remove<int, char>(std::begin(entities), std::end(entities));
     registry.remove<int, char>(std::begin(entities), std::end(entities));
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<char>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<char>().size(), 0u);
 
     ASSERT_FALSE(registry.orphan(entities[0u]));
     ASSERT_TRUE(registry.orphan(entities[1u]));
@@ -1606,9 +1606,9 @@ TEST(Registry, StableRemove) {
     ASSERT_FALSE(registry.all_of<int>(entities[1u]));
     ASSERT_TRUE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 1u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 1u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 
     ASSERT_EQ((registry.remove<int>(iview.begin(), iview.end())), 1u);
 
@@ -1617,9 +1617,9 @@ TEST(Registry, StableRemove) {
 
     ASSERT_FALSE(registry.any_of<int>(entities[2u]));
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
-    ASSERT_EQ(registry.size<double>(), 1u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
+    ASSERT_EQ(registry.storage<double>().size(), 1u);
 }
 
 TEST(Registry, Compact) {
@@ -1634,23 +1634,23 @@ TEST(Registry, Compact) {
     registry.emplace<int>(entities[1u]);
     registry.emplace<stable_type>(entities[1u]);
 
-    ASSERT_EQ(registry.size<int>(), 2u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
+    ASSERT_EQ(registry.storage<int>().size(), 2u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
 
     registry.destroy(std::begin(entities), std::end(entities));
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
 
     registry.compact<int>();
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 2u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 2u);
 
     registry.compact();
 
-    ASSERT_EQ(registry.size<int>(), 0u);
-    ASSERT_EQ(registry.size<stable_type>(), 0u);
+    ASSERT_EQ(registry.storage<int>().size(), 0u);
+    ASSERT_EQ(registry.storage<stable_type>().size(), 0u);
 }
 
 TEST(Registry, NonOwningGroupInterleaved) {

test/entt/entity/snapshot.cpp

@@ -377,7 +377,7 @@ TEST(Snapshot, Continuous) {
 
     dst.view<noncopyable_component>().each([&dst, &noncopyable_component_cnt](auto, const auto &component) {
         ++noncopyable_component_cnt;
-        ASSERT_EQ(component.value, static_cast<int>(dst.size<noncopyable_component>() - noncopyable_component_cnt - 1u));
+        ASSERT_EQ(component.value, static_cast<int>(dst.storage<noncopyable_component>().size() - noncopyable_component_cnt - 1u));
     });
 
     src.view<another_component>().each([](auto, auto &component) {
@@ -400,11 +400,11 @@ TEST(Snapshot, Continuous) {
 
     ASSERT_EQ(size, dst.size());
 
-    ASSERT_EQ(dst.size<a_component>(), a_component_cnt);
-    ASSERT_EQ(dst.size<another_component>(), another_component_cnt);
-    ASSERT_EQ(dst.size<what_a_component>(), what_a_component_cnt);
-    ASSERT_EQ(dst.size<map_component>(), map_component_cnt);
-    ASSERT_EQ(dst.size<noncopyable_component>(), noncopyable_component_cnt);
+    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
+    ASSERT_EQ(dst.storage<another_component>().size(), another_component_cnt);
+    ASSERT_EQ(dst.storage<what_a_component>().size(), what_a_component_cnt);
+    ASSERT_EQ(dst.storage<map_component>().size(), map_component_cnt);
+    ASSERT_EQ(dst.storage<noncopyable_component>().size(), noncopyable_component_cnt);
 
     dst.view<another_component>().each([](auto, auto &component) {
         ASSERT_EQ(component.value, component.key < 0 ? -1 : (2 * component.key));
@@ -466,7 +466,7 @@ TEST(Snapshot, Continuous) {
     });
 
     dst.clear<a_component>();
-    a_component_cnt = src.size<a_component>();
+    a_component_cnt = src.storage<a_component>().size();
 
     entt::snapshot{src}.entities(output).component<a_component, what_a_component, map_component, another_component>(output);
 
@@ -480,7 +480,7 @@ TEST(Snapshot, Continuous) {
             &map_component::both)
         .orphans();
 
-    ASSERT_EQ(dst.size<a_component>(), a_component_cnt);
+    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
 
     src.clear<a_component>();
     a_component_cnt = {};
@@ -497,7 +497,7 @@ TEST(Snapshot, Continuous) {
             &map_component::both)
         .orphans();
 
-    ASSERT_EQ(dst.size<a_component>(), a_component_cnt);
+    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
 }
 
 TEST(Snapshot, MoreOnShrink) {

test/lib/registry/main.cpp

@@ -18,7 +18,7 @@ TEST(Lib, Registry) {
     emplace_velocity(registry);
     update_position(registry);
 
-    ASSERT_EQ(registry.size<position>(), registry.size<velocity>());
+    ASSERT_EQ(registry.storage<position>().size(), registry.storage<velocity>().size());
 
     registry.view<position>().each([](auto entity, auto &position) {
         ASSERT_EQ(position.x, static_cast<int>(entt::to_integral(entity) + 16));

test/lib/registry_plugin/main.cpp

@@ -18,8 +18,8 @@ TEST(Lib, Registry) {
     ctx.userdata = &registry;
     cr_plugin_update(ctx);
 
-    ASSERT_EQ(registry.size<position>(), registry.size<velocity>());
-    ASSERT_EQ(registry.size<position>(), registry.size());
+    ASSERT_EQ(registry.storage<position>().size(), registry.storage<velocity>().size());
+    ASSERT_EQ(registry.storage<position>().size(), registry.size());
 
     registry.view<position>().each([](auto entity, auto &position) {
         ASSERT_EQ(position.x, static_cast<int>(entt::to_integral(entity) + 16u));