Scarfski/entt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sparse_set: remove -> erase

Browse Source
This commit is contained in:
Michele Caini
2021-04-21 15:46:02 +02:00
parent 120918bc37
commit 4bbf93fd0c
7 changed files with 42 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/entt/entity/observer.hpp
View File

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

12
src/entt/entity/registry.hpp
View File

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

22
src/entt/entity/sparse_set.hpp
View File

@@ -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:

6
src/entt/entity/storage.hpp
View File

@@ -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:

10
test/entt/entity/poly_storage.cpp
View File

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

16
test/entt/entity/sparse_set.cpp
View File

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

14
test/entt/entity/storage.cpp
View File

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