From 4bbf93fd0cdb7ce06c3f340a5c96b07fe5b25acb Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Wed, 21 Apr 2021 15:46:02 +0200 Subject: [PATCH] sparse_set: remove -> erase --- src/entt/entity/observer.hpp | 4 ++-- src/entt/entity/registry.hpp | 12 ++++++------ src/entt/entity/sparse_set.hpp | 22 +++++++++++----------- src/entt/entity/storage.hpp | 6 +++--- test/entt/entity/poly_storage.cpp | 10 +++++----- test/entt/entity/sparse_set.cpp | 16 ++++++++-------- test/entt/entity/storage.cpp | 14 +++++++------- 7 files changed, 42 insertions(+), 42 deletions(-) diff --git a/src/entt/entity/observer.hpp b/src/entt/entity/observer.hpp index e8acdc594..366520349 100644 --- a/src/entt/entity/observer.hpp +++ b/src/entt/entity/observer.hpp @@ -191,7 +191,7 @@ class basic_observer { template static void discard_if(basic_observer &obs, basic_registry &, 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 static void discard_if(basic_observer &obs, basic_registry &, const Entity entt) { if(obs.storage.contains(entt) && !(obs.storage.get(entt) &= (~(1 << Index)))) { - obs.storage.remove(entt); + obs.storage.erase(entt); } } diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp index d02ee3107..4f8dfcd39 100644 --- a/src/entt/entity/registry.hpp +++ b/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()...); 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()->remove(entity, this), ...); + (assure()->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()->remove(first, last, this), ...); + (assure()->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()) + ... + 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::begin(), cpool->basic_sparse_set::end(), this); + cpool->erase(cpool->basic_sparse_set::begin(), cpool->basic_sparse_set::end(), this); }(assure()), ...); } } diff --git a/src/entt/entity/sparse_set.hpp b/src/entt/entity/sparse_set.hpp index 877683469..a6a5cfdd2 100644 --- a/src/entt/entity/sparse_set.hpp +++ b/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 - 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: diff --git a/src/entt/entity/storage.hpp b/src/entt/entity/storage.hpp index f39a1e006..7d37f28a4 100644 --- a/src/entt/entity/storage.hpp +++ b/src/entt/entity/storage.hpp @@ -626,11 +626,11 @@ struct storage_adapter_mixin: Type { */ template 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 *>(ud), entity); - Type::about_to_remove(entity, ud); + Type::about_to_erase(entity, ud); } public: diff --git a/test/entt/entity/poly_storage.cpp b/test/entt/entity/poly_storage.cpp index 84d963bbc..0c8388715 100644 --- a/test/entt/entity/poly_storage.cpp +++ b/test/entt/entity/poly_storage.cpp @@ -24,7 +24,7 @@ struct PolyStorage: entt::type_list_cat_t< struct type: entt::Storage::template type { static constexpr auto base = decltype(as_type_list(std::declval>()))::size; - void remove(entt::basic_registry &owner, const entity_type *first, const entity_type *last) { + void erase(entt::basic_registry &owner, const entity_type *first, const entity_type *last) { entt::poly_call(*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::template impl, entt::value_list< - &Type::template remove, + &Type::template erase, &members::emplace, &members::get, &members::copy_to @@ -128,14 +128,14 @@ TEST(PolyStorage, Constness) { entity[0] = registry.create(); registry.emplace(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()); - 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(entity[0])); auto &&storage = registry.storage(entt::type_id()); - storage->remove(registry, std::begin(entity), std::end(entity)); + storage->erase(registry, std::begin(entity), std::end(entity)); ASSERT_FALSE(registry.all_of(entity[0])); } diff --git a/test/entt/entity/sparse_set.cpp b/test/entt/entity/sparse_set.cpp index b98b5ef10..0cdfcc929 100644 --- a/test/entt/entity/sparse_set.cpp +++ b/test/entt/entity/sparse_set.cpp @@ -37,7 +37,7 @@ TEST(SparseSet, Functionalities) { ASSERT_EQ(set.at(1u), static_cast(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}); diff --git a/test/entt/entity/storage.cpp b/test/entt/entity/storage.cpp index 17461c4f7..aaeede502 100644 --- a/test/entt/entity/storage.cpp +++ b/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> 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)); };