sparse_set: ::remove returns number of actually removed elements

src/entt/entity/registry.hpp

@@ -83,9 +83,7 @@ class basic_registry {
 
         void discard_if([[maybe_unused]] basic_registry &owner, const Entity entt) {
             if constexpr(sizeof...(Owned) == 0) {
-                if(current.contains(entt)) {
-                    current.erase(entt);
-                }
+                current.remove(entt);
             } else {
                 if(const auto cpools = std::make_tuple(owner.assure<Owned>()...); std::get<0>(cpools)->contains(entt) && (std::get<0>(cpools)->index(entt) < current)) {
                     const auto pos = --current;

src/entt/entity/sparse_set.hpp

@@ -496,11 +496,10 @@ public:
      * @brief Removes an entity from a sparse set if it exists.
      * @param entt A valid entity identifier.
      * @param ud Optional user data that are forwarded as-is to derived classes.
+     * @return True if the entity is actually removed, false otherwise.
      */
-    void remove(const entity_type entt, void *ud = nullptr) {
-        if(contains(entt)) {
-            erase(entt, ud);
-        }
+    bool remove(const entity_type entt, void *ud = nullptr) {
+        return contains(entt) ? (erase(entt, ud), true) : false;
     }
 
     /**
@@ -509,12 +508,17 @@ public:
      * @param first An iterator to the first element of the range of entities.
      * @param last An iterator past the last element of the range of entities.
      * @param ud Optional user data that are forwarded as-is to derived classes.
+     * @return The number of entities actually removed.
      */
     template<typename It>
-    void remove(It first, It last, void *ud = nullptr) {
+    size_type remove(It first, It last, void *ud = nullptr) {
+        size_type count{};
+
         for(; first != last; ++first) {
-            remove(*first, ud);
+            count += remove(*first, ud);
         }
+
+        return count;
     }
 
     /**

test/entt/entity/sparse_set.cpp

@@ -198,36 +198,35 @@ TEST(SparseSet, Remove) {
 
     ASSERT_TRUE(set.empty());
 
-    set.remove(std::begin(entities), std::end(entities));
-    set.remove(entities[1]);
+    ASSERT_EQ(set.remove(std::begin(entities), std::end(entities)), 0u);
+    ASSERT_EQ(set.remove(entities[1]), 0u);
 
     ASSERT_TRUE(set.empty());
 
     set.insert(std::begin(entities), std::end(entities));
-    set.remove(set.begin(), set.end());
 
+    ASSERT_EQ(set.remove(set.begin(), set.end()), 3u);
     ASSERT_TRUE(set.empty());
 
     set.insert(std::begin(entities), std::end(entities));
-    set.remove(entities, entities + 2u);
 
+    ASSERT_EQ(set.remove(entities, entities + 2u), 2u);
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(*set.begin(), entt::entity{9});
 
-    set.remove(entities[2]);
-    set.remove(entities[2]);
-
+    ASSERT_EQ(set.remove(entities[2]), 1u);
+    ASSERT_EQ(set.remove(entities[2]), 0u);
     ASSERT_TRUE(set.empty());
 
     set.insert(entities, entities + 2u);
-    set.remove(std::begin(entities), std::end(entities));
 
+    ASSERT_EQ(set.remove(std::begin(entities), std::end(entities)), 2u);
     ASSERT_TRUE(set.empty());
 
     set.insert(std::begin(entities), std::end(entities));
     std::swap(entities[1], entities[2]);
-    set.remove(entities, entities + 2u);
 
+    ASSERT_EQ(set.remove(entities, entities + 2u), 2u);
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(*set.begin(), entt::entity{42});
 }

test/entt/entity/storage.cpp

@@ -181,30 +181,29 @@ TEST(Storage, Remove) {
     pool.emplace(entities[0]);
     pool.emplace(entities[1]);
     pool.emplace(entities[2]);
-    pool.remove(std::begin(entities), std::end(entities));
-    pool.remove(std::begin(entities), std::end(entities));
 
+    ASSERT_EQ(pool.remove(std::begin(entities), std::end(entities)), 3u);
+    ASSERT_EQ(pool.remove(std::begin(entities), std::end(entities)), 0u);
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entities[0], 0);
     pool.emplace(entities[1], 1);
     pool.emplace(entities[2], 2);
-    pool.remove(entities, entities + 2u);
 
+    ASSERT_EQ(pool.remove(entities, entities + 2u), 2u);
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(*pool.begin(), 2);
 
-    pool.remove(entities[2]);
-    pool.remove(entities[2]);
-
+    ASSERT_EQ(pool.remove(entities[2]), 1u);
+    ASSERT_EQ(pool.remove(entities[2]), 0u);
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entities[0], 0);
     pool.emplace(entities[1], 1);
     pool.emplace(entities[2], 2);
     std::swap(entities[1], entities[2]);
-    pool.remove(entities, entities + 2u);
 
+    ASSERT_EQ(pool.remove(entities, entities + 2u), 2u);
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(*pool.begin(), 1);
 }