sparse_set: remove -> erase

src/entt/entity/observer.hpp

@@ -191,7 +191,7 @@ class basic_observer {
         template<std::size_t Index>
         static void discard_if(basic_observer &obs, basic_registry<Entity> &, const Entity entt) {
             if(obs.storage.contains(entt) && !(obs.storage.get(entt) &= (~(1 << Index)))) {
-                obs.storage.remove(entt);
+                obs.storage.erase(entt);
             }
         }
 
@@ -234,7 +234,7 @@ class basic_observer {
         template<std::size_t Index>
         static void discard_if(basic_observer &obs, basic_registry<Entity> &, const Entity entt) {
             if(obs.storage.contains(entt) && !(obs.storage.get(entt) &= (~(1 << Index)))) {
-                obs.storage.remove(entt);
+                obs.storage.erase(entt);
             }
         }
 

src/entt/entity/registry.hpp

@@ -84,7 +84,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.remove(entt);
+                    current.erase(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)) {
@@ -674,7 +674,7 @@ public:
     void remove(const entity_type entity) {
         ENTT_ASSERT(valid(entity), "Invalid entity");
         static_assert(sizeof...(Component) > 0, "Provide one or more component types");
-        (assure<Component>()->remove(entity, this), ...);
+        (assure<Component>()->erase(entity, this), ...);
     }
 
     /**
@@ -691,7 +691,7 @@ public:
     void remove(It first, It last) {
         ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); }), "Invalid entity");
         static_assert(sizeof...(Component) > 0, "Provide one or more component types");
-        (assure<Component>()->remove(first, last, this), ...);
+        (assure<Component>()->erase(first, last, this), ...);
     }
 
     /**
@@ -717,7 +717,7 @@ public:
         ENTT_ASSERT(valid(entity), "Invalid entity");
 
         return ([this, entity](auto *cpool) {
-            return cpool->contains(entity) ? (cpool->remove(entity, this), true) : false;
+            return cpool->contains(entity) ? (cpool->erase(entity, this), true) : false;
         }(assure<Component>()) + ... + size_type{});
     }
 
@@ -741,7 +741,7 @@ public:
 
         for(auto pos = pools.size(); pos; --pos) {
             if(auto &pdata = pools[pos-1]; pdata.pool && pdata.pool->contains(entity)) {
-                pdata.pool->remove(std::begin(wrap), std::end(wrap), this);
+                pdata.pool->erase(std::begin(wrap), std::end(wrap), this);
             }
         }
     }
@@ -897,7 +897,7 @@ public:
             each([this](const auto entity) { release_entity(entity, version(entity) + 1u); });
         } else {
             ([this](auto *cpool) {
-                cpool->remove(cpool->basic_sparse_set<entity_type>::begin(), cpool->basic_sparse_set<entity_type>::end(), this);
+                cpool->erase(cpool->basic_sparse_set<entity_type>::begin(), cpool->basic_sparse_set<entity_type>::end(), this);
             }(assure<Component>()), ...);
         }
     }

src/entt/entity/sparse_set.hpp

@@ -181,17 +181,17 @@ protected:
     virtual void swap_at([[maybe_unused]] const std::size_t lhs, [[maybe_unused]] const std::size_t rhs) {}
 
     /**
-     * @brief Attempts to remove an entity from the internal packed array.
+     * @brief Attempts to erase an entity from the internal packed array.
      * @param pos A valid position of an entity within storage.
      */
     virtual void swap_and_pop([[maybe_unused]] const std::size_t pos) {}
 
     /**
-     * @brief Last chance to use an entity that is about to be removed.
+     * @brief Last chance to use an entity that is about to be erased.
      * @param entity A valid entity identifier.
      * @param ud Optional user data that are forwarded as-is to derived classes.
      */
-    virtual void about_to_remove([[maybe_unused]] const Entity entity, [[maybe_unused]] void *ud) {}
+    virtual void about_to_erase([[maybe_unused]] const Entity entity, [[maybe_unused]] void *ud) {}
 
 public:
     /*! @brief Underlying entity identifier. */
@@ -448,20 +448,20 @@ public:
     }
 
     /**
-     * @brief Removes an entity from a sparse set.
+     * @brief Erases an entity from a sparse set.
      *
      * @warning
-     * Attempting to remove an entity that doesn't belong to the sparse set
+     * Attempting to erase an entity that doesn't belong to the sparse set
      * results in undefined behavior.
      *
      * @param entt A valid entity identifier.
      * @param ud Optional user data that are forwarded as-is to derived classes.
      */
-    void remove(const entity_type entt, void *ud = nullptr) {
+    void erase(const entity_type entt, void *ud = nullptr) {
         ENTT_ASSERT(contains(entt), "Set does not contain entity");
 
         // last chance to use the entity for derived classes and mixins, if any
-        about_to_remove(entt, ud);
+        about_to_erase(entt, ud);
 
         auto &ref = sparse[page(entt)][offset(entt)];
         const auto pos = size_type{to_integral(ref)};
@@ -479,16 +479,16 @@ public:
     }
 
     /**
-     * @brief Removes multiple entities from a pool.
+     * @brief Erases multiple entities from a set.
      * @tparam It Type of input iterator.
      * @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.
      */
     template<typename It>
-    void remove(It first, It last, void *ud = nullptr) {
+    void erase(It first, It last, void *ud = nullptr) {
         for(; first != last; ++first) {
-            remove(*first, ud);
+            erase(*first, ud);
         }
     }
 
@@ -620,7 +620,7 @@ public:
      * @param ud Optional user data that are forwarded as-is to derived classes.
      */
     void clear(void *ud = nullptr) ENTT_NOEXCEPT {
-        remove(begin(), end(), ud);
+        erase(begin(), end(), ud);
     }
 
 private:

src/entt/entity/storage.hpp

@@ -626,11 +626,11 @@ struct storage_adapter_mixin: Type {
  */
 template<typename Type>
 class sigh_storage_mixin final: public Type {
-    /*! @copydoc basic_sparse_set::about_to_remove */
-    void about_to_remove(const typename Type::entity_type entity, void *ud) final {
+    /*! @copydoc basic_sparse_set::about_to_erase */
+    void about_to_erase(const typename Type::entity_type entity, void *ud) final {
         ENTT_ASSERT(ud != nullptr, "Invalid pointer to registry");
         destruction.publish(*static_cast<basic_registry<typename Type::entity_type> *>(ud), entity);
-        Type::about_to_remove(entity, ud);
+        Type::about_to_erase(entity, ud);
     }
 
 public:

test/entt/entity/poly_storage.cpp

@@ -24,7 +24,7 @@ struct PolyStorage: entt::type_list_cat_t<
     struct type: entt::Storage<Entity>::template type<Base> {
         static constexpr auto base = decltype(as_type_list(std::declval<entt::Storage<Entity>>()))::size;
 
-        void remove(entt::basic_registry<Entity> &owner, const entity_type *first, const entity_type *last) {
+        void erase(entt::basic_registry<Entity> &owner, const entity_type *first, const entity_type *last) {
             entt::poly_call<base + 0>(*this, first, last, &owner);
         }
 
@@ -60,7 +60,7 @@ struct PolyStorage: entt::type_list_cat_t<
     using impl = entt::value_list_cat_t<
         typename entt::Storage<Entity>::template impl<Type>,
         entt::value_list<
-            &Type::template remove<const entity_type *>,
+            &Type::template erase<const entity_type *>,
             &members<Type>::emplace,
             &members<Type>::get,
             &members<Type>::copy_to
@@ -128,14 +128,14 @@ TEST(PolyStorage, Constness) {
     entity[0] = registry.create();
     registry.emplace<int>(entity[0], 42);
 
-    // cannot invoke remove on a const storage, let's copy the returned value
+    // cannot invoke erase on a const storage, let's copy the returned value
     auto cstorage = cregistry.storage(entt::type_id<int>());
 
-    ASSERT_DEATH(cstorage->remove(registry, std::begin(entity), std::end(entity)), "");
+    ASSERT_DEATH(cstorage->erase(registry, std::begin(entity), std::end(entity)), "");
     ASSERT_TRUE(registry.all_of<int>(entity[0]));
 
     auto &&storage = registry.storage(entt::type_id<int>());
-    storage->remove(registry, std::begin(entity), std::end(entity));
+    storage->erase(registry, std::begin(entity), std::end(entity));
 
     ASSERT_FALSE(registry.all_of<int>(entity[0]));
 }

test/entt/entity/sparse_set.cpp

@@ -37,7 +37,7 @@ TEST(SparseSet, Functionalities) {
     ASSERT_EQ(set.at(1u), static_cast<entt::entity>(entt::null));
     ASSERT_EQ(set[0u], entt::entity{42});
 
-    set.remove(entt::entity{42});
+    set.erase(entt::entity{42});
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
@@ -101,14 +101,14 @@ TEST(SparseSet, Pagination) {
     ASSERT_TRUE(set.contains(entt::entity{page_size}));
     ASSERT_FALSE(set.contains(entt::entity{page_size+1}));
 
-    set.remove(entt::entity{page_size-1});
+    set.erase(entt::entity{page_size-1});
 
     ASSERT_EQ(set.extent(), 2 * page_size);
     ASSERT_FALSE(set.contains(entt::entity{page_size-1}));
     ASSERT_TRUE(set.contains(entt::entity{page_size}));
 
     set.shrink_to_fit();
-    set.remove(entt::entity{page_size});
+    set.erase(entt::entity{page_size});
 
     ASSERT_EQ(set.extent(), 2 * page_size);
     ASSERT_FALSE(set.contains(entt::entity{page_size-1}));
@@ -149,7 +149,7 @@ TEST(SparseSet, Insert) {
     ASSERT_EQ(set.data()[set.index(entt::entity{24})], entt::entity{24});
 }
 
-TEST(SparseSet, Remove) {
+TEST(SparseSet, Erase) {
     entt::sparse_set set;
     entt::entity entities[3];
 
@@ -158,17 +158,17 @@ TEST(SparseSet, Remove) {
     entities[2] = entt::entity{9};
 
     set.insert(std::begin(entities), std::end(entities));
-    set.remove(set.begin(), set.end());
+    set.erase(set.begin(), set.end());
 
     ASSERT_TRUE(set.empty());
 
     set.insert(std::begin(entities), std::end(entities));
-    set.remove(set.begin(), set.end());
+    set.erase(set.begin(), set.end());
 
     ASSERT_TRUE(set.empty());
 
     set.insert(std::begin(entities), std::end(entities));
-    set.remove(entities, entities + 2u);
+    set.erase(entities, entities + 2u);
 
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(*set.begin(), entt::entity{9});
@@ -176,7 +176,7 @@ TEST(SparseSet, Remove) {
     set.clear();
     set.insert(std::begin(entities), std::end(entities));
     std::swap(entities[1], entities[2]);
-    set.remove(entities, entities + 2u);
+    set.erase(entities, entities + 2u);
 
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(*set.begin(), entt::entity{42});

test/entt/entity/storage.cpp

@@ -27,7 +27,7 @@ struct throwing_component {
 struct update_from_destructor {
     ~update_from_destructor() {
         if(target != entt::null) {
-            storage->remove(target);
+            storage->erase(target);
         }
     }
 
@@ -58,7 +58,7 @@ TEST(Storage, Functionalities) {
     ASSERT_TRUE(pool.contains(entt::entity{41}));
     ASSERT_EQ(pool.get(entt::entity{41}), 3);
 
-    pool.remove(entt::entity{41});
+    pool.erase(entt::entity{41});
 
     ASSERT_TRUE(pool.empty());
     ASSERT_EQ(pool.size(), 0u);
@@ -137,14 +137,14 @@ TEST(Storage, Remove) {
 
     pool.emplace(entt::entity{3});
     pool.emplace(entt::entity{42});
-    base.remove(base.begin(), base.end());
+    base.erase(base.begin(), base.end());
 
     ASSERT_TRUE(pool.empty());
 
     pool.emplace(entt::entity{3}, 3);
     pool.emplace(entt::entity{42}, 42);
     pool.emplace(entt::entity{9}, 9);
-    base.remove(base.rbegin(), base.rbegin() + 2u);
+    base.erase(base.rbegin(), base.rbegin() + 2u);
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(*pool.begin(), 9);
@@ -155,7 +155,7 @@ TEST(Storage, Remove) {
     pool.emplace(entt::entity{9}, 9);
 
     entt::entity entities[2]{entt::entity{3}, entt::entity{9}};
-    base.remove(std::begin(entities), std::end(entities));
+    base.erase(std::begin(entities), std::end(entities));
 
     ASSERT_FALSE(pool.empty());
     ASSERT_EQ(*pool.begin(), 42);
@@ -171,7 +171,7 @@ TEST(Storage, TypesFromStandardTemplateLibraryMustWork) {
     // see #37 - this test shouldn't crash, that's all
     entt::storage<std::unordered_set<int>> pool;
     pool.emplace(entt::entity{0}).insert(42);
-    pool.remove(entt::entity{0});
+    pool.erase(entt::entity{0});
 }
 
 TEST(Storage, Iterator) {
@@ -676,7 +676,7 @@ TEST(Storage, UpdateFromDestructor) {
         }
 
         pool.get(entt::entity(size/2)).target = target;
-        pool.remove(entt::entity(size/2));
+        pool.erase(entt::entity(size/2));
 
         ASSERT_EQ(pool.size(), size - 1u - (target != entt::null));
     };