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

sparse set: removed deprecated functions

Browse Source
This commit is contained in:
Michele Caini
2020-05-10 16:28:06 +02:00
parent 1d61c0d970
commit 89515b0e30
3 changed files with 118 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -342,12 +342,6 @@ public:
return (curr < sparse.size() && sparse[curr] && sparse[curr][offset(entt)] != null);
}
/*! @copydoc contains */
[[deprecated("use ::contains instead")]]
bool has(const entity_type entt) const {
return contains(entt);
}
/**
* @brief Returns the position of an entity in a sparse set.
*
@@ -382,12 +376,6 @@ public:
packed.push_back(entt);
}
/*! @copydoc emplace */
[[deprecated("use ::emplace instead")]]
void construct(const entity_type entt) {
emplace(entt);
}
/**
* @brief Assigns one or more entities to a sparse set.
*
@@ -413,13 +401,6 @@ public:
}
}
/*! @copydoc insert */
template<typename It>
[[deprecated("use ::insert instead")]]
void construct(It first, It last) {
insert(std::move(first), std::move(last));
}
/**
* @brief Removes an entity from a sparse set.
*
@@ -441,12 +422,6 @@ public:
packed.pop_back();
}
/*! @copydoc erase */
[[deprecated("use ::erase instead")]]
void destroy(const entity_type entt) {
erase(entt);
}
/**
* @brief Swaps two entities in the internal packed array.
*

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

@@ -21,10 +21,10 @@ TEST(SparseSet, Functionalities) {
ASSERT_EQ(set.size(), 0u);
ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
ASSERT_EQ(set.begin(), set.end());
ASSERT_FALSE(set.has(entt::entity{0}));
ASSERT_FALSE(set.has(entt::entity{42}));
ASSERT_FALSE(set.contains(entt::entity{0}));
ASSERT_FALSE(set.contains(entt::entity{42}));
set.construct(entt::entity{42});
set.emplace(entt::entity{42});
ASSERT_EQ(set.index(entt::entity{42}), 0u);
@@ -32,20 +32,20 @@ TEST(SparseSet, Functionalities) {
ASSERT_EQ(set.size(), 1u);
ASSERT_NE(std::as_const(set).begin(), std::as_const(set).end());
ASSERT_NE(set.begin(), set.end());
ASSERT_FALSE(set.has(entt::entity{0}));
ASSERT_TRUE(set.has(entt::entity{42}));
ASSERT_FALSE(set.contains(entt::entity{0}));
ASSERT_TRUE(set.contains(entt::entity{42}));
ASSERT_EQ(set.index(entt::entity{42}), 0u);
set.destroy(entt::entity{42});
set.erase(entt::entity{42});
ASSERT_TRUE(set.empty());
ASSERT_EQ(set.size(), 0u);
ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
ASSERT_EQ(set.begin(), set.end());
ASSERT_FALSE(set.has(entt::entity{0}));
ASSERT_FALSE(set.has(entt::entity{42}));
ASSERT_FALSE(set.contains(entt::entity{0}));
ASSERT_FALSE(set.contains(entt::entity{42}));
set.construct(entt::entity{42});
set.emplace(entt::entity{42});
ASSERT_FALSE(set.empty());
ASSERT_EQ(set.index(entt::entity{42}), 0u);
@@ -68,8 +68,8 @@ TEST(SparseSet, Functionalities) {
ASSERT_EQ(other.size(), 0u);
ASSERT_EQ(std::as_const(other).begin(), std::as_const(other).end());
ASSERT_EQ(other.begin(), other.end());
ASSERT_FALSE(other.has(entt::entity{0}));
ASSERT_FALSE(other.has(entt::entity{42}));
ASSERT_FALSE(other.contains(entt::entity{0}));
ASSERT_FALSE(other.contains(entt::entity{42}));
}
TEST(SparseSet, Pagination) {
@@ -78,30 +78,30 @@ TEST(SparseSet, Pagination) {
ASSERT_EQ(set.extent(), 0);
set.construct(entt::entity{entt_per_page-1});
set.emplace(entt::entity{entt_per_page-1});
ASSERT_EQ(set.extent(), entt_per_page);
ASSERT_TRUE(set.has(entt::entity{entt_per_page-1}));
ASSERT_TRUE(set.contains(entt::entity{entt_per_page-1}));
set.construct(entt::entity{entt_per_page});
set.emplace(entt::entity{entt_per_page});
ASSERT_EQ(set.extent(), 2 * entt_per_page);
ASSERT_TRUE(set.has(entt::entity{entt_per_page-1}));
ASSERT_TRUE(set.has(entt::entity{entt_per_page}));
ASSERT_FALSE(set.has(entt::entity{entt_per_page+1}));
ASSERT_TRUE(set.contains(entt::entity{entt_per_page-1}));
ASSERT_TRUE(set.contains(entt::entity{entt_per_page}));
ASSERT_FALSE(set.contains(entt::entity{entt_per_page+1}));
set.destroy(entt::entity{entt_per_page-1});
set.erase(entt::entity{entt_per_page-1});
ASSERT_EQ(set.extent(), 2 * entt_per_page);
ASSERT_FALSE(set.has(entt::entity{entt_per_page-1}));
ASSERT_TRUE(set.has(entt::entity{entt_per_page}));
ASSERT_FALSE(set.contains(entt::entity{entt_per_page-1}));
ASSERT_TRUE(set.contains(entt::entity{entt_per_page}));
set.shrink_to_fit();
set.destroy(entt::entity{entt_per_page});
set.erase(entt::entity{entt_per_page});
ASSERT_EQ(set.extent(), 2 * entt_per_page);
ASSERT_FALSE(set.has(entt::entity{entt_per_page-1}));
ASSERT_FALSE(set.has(entt::entity{entt_per_page}));
ASSERT_FALSE(set.contains(entt::entity{entt_per_page-1}));
ASSERT_FALSE(set.contains(entt::entity{entt_per_page}));
set.shrink_to_fit();
@@ -115,16 +115,16 @@ TEST(SparseSet, BatchAdd) {
entities[0] = entt::entity{3};
entities[1] = entt::entity{42};
set.construct(entt::entity{12});
set.construct(std::begin(entities), std::end(entities));
set.construct(entt::entity{24});
set.emplace(entt::entity{12});
set.insert(std::begin(entities), std::end(entities));
set.emplace(entt::entity{24});
ASSERT_TRUE(set.has(entities[0]));
ASSERT_TRUE(set.has(entities[1]));
ASSERT_FALSE(set.has(entt::entity{0}));
ASSERT_FALSE(set.has(entt::entity{9}));
ASSERT_TRUE(set.has(entt::entity{12}));
ASSERT_TRUE(set.has(entt::entity{24}));
ASSERT_TRUE(set.contains(entities[0]));
ASSERT_TRUE(set.contains(entities[1]));
ASSERT_FALSE(set.contains(entt::entity{0}));
ASSERT_FALSE(set.contains(entt::entity{9}));
ASSERT_TRUE(set.contains(entt::entity{12}));
ASSERT_TRUE(set.contains(entt::entity{24}));
ASSERT_FALSE(set.empty());
ASSERT_EQ(set.size(), 4u);
@@ -142,7 +142,7 @@ TEST(SparseSet, Iterator) {
using iterator = typename entt::sparse_set<entt::entity>::iterator;
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{3});
set.emplace(entt::entity{3});
iterator end{set.begin()};
iterator begin{};
@@ -185,9 +185,9 @@ TEST(SparseSet, Iterator) {
TEST(SparseSet, Find) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{3});
set.construct(entt::entity{42});
set.construct(entt::entity{99});
set.emplace(entt::entity{3});
set.emplace(entt::entity{42});
set.emplace(entt::entity{99});
ASSERT_NE(set.find(entt::entity{3}), set.end());
ASSERT_NE(set.find(entt::entity{42}), set.end());
@@ -206,9 +206,9 @@ TEST(SparseSet, Find) {
TEST(SparseSet, Data) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{3});
set.construct(entt::entity{12});
set.construct(entt::entity{42});
set.emplace(entt::entity{3});
set.emplace(entt::entity{12});
set.emplace(entt::entity{42});
ASSERT_EQ(set.index(entt::entity{3}), 0u);
ASSERT_EQ(set.index(entt::entity{12}), 1u);
@@ -222,11 +222,11 @@ TEST(SparseSet, Data) {
TEST(SparseSet, SortOrdered) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{42});
set.construct(entt::entity{12});
set.construct(entt::entity{9});
set.construct(entt::entity{7});
set.construct(entt::entity{3});
set.emplace(entt::entity{42});
set.emplace(entt::entity{12});
set.emplace(entt::entity{9});
set.emplace(entt::entity{7});
set.emplace(entt::entity{3});
ASSERT_EQ(*(set.data() + 0u), entt::entity{42});
ASSERT_EQ(*(set.data() + 1u), entt::entity{12});
@@ -262,11 +262,11 @@ TEST(SparseSet, SortOrdered) {
TEST(SparseSet, SortReverse) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{3});
set.construct(entt::entity{7});
set.construct(entt::entity{9});
set.construct(entt::entity{12});
set.construct(entt::entity{42});
set.emplace(entt::entity{3});
set.emplace(entt::entity{7});
set.emplace(entt::entity{9});
set.emplace(entt::entity{12});
set.emplace(entt::entity{42});
ASSERT_EQ(*(set.data() + 0u), entt::entity{3});
ASSERT_EQ(*(set.data() + 1u), entt::entity{7});
@@ -302,11 +302,11 @@ TEST(SparseSet, SortReverse) {
TEST(SparseSet, SortUnordered) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{9});
set.construct(entt::entity{7});
set.construct(entt::entity{3});
set.construct(entt::entity{12});
set.construct(entt::entity{42});
set.emplace(entt::entity{9});
set.emplace(entt::entity{7});
set.emplace(entt::entity{3});
set.emplace(entt::entity{12});
set.emplace(entt::entity{42});
ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
ASSERT_EQ(*(set.data() + 1u), entt::entity{7});
@@ -342,11 +342,11 @@ TEST(SparseSet, SortUnordered) {
TEST(SparseSet, SortRange) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{9});
set.construct(entt::entity{7});
set.construct(entt::entity{3});
set.construct(entt::entity{12});
set.construct(entt::entity{42});
set.emplace(entt::entity{9});
set.emplace(entt::entity{7});
set.emplace(entt::entity{3});
set.emplace(entt::entity{12});
set.emplace(entt::entity{42});
ASSERT_EQ(*(set.data() + 0u), entt::entity{9});
ASSERT_EQ(*(set.data() + 1u), entt::entity{7});
@@ -406,7 +406,7 @@ TEST(SparseSet, SortRange) {
TEST(SparseSet, ArrangOrdered) {
entt::sparse_set<entt::entity> set;
entt::entity entities[5]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}};
set.construct(std::begin(entities), std::end(entities));
set.insert(std::begin(entities), std::end(entities));
set.arrange(set.begin(), set.end(), [](auto...) { FAIL(); }, std::less{});
@@ -428,7 +428,7 @@ TEST(SparseSet, ArrangOrdered) {
TEST(SparseSet, ArrangeReverse) {
entt::sparse_set<entt::entity> set;
entt::entity entities[5]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}};
set.construct(std::begin(entities), std::end(entities));
set.insert(std::begin(entities), std::end(entities));
set.arrange(set.begin(), set.end(), [&set, &entities](const auto lhs, const auto rhs) {
std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
@@ -452,7 +452,7 @@ TEST(SparseSet, ArrangeReverse) {
TEST(SparseSet, ArrangeUnordered) {
entt::sparse_set<entt::entity> set;
entt::entity entities[5]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
set.construct(std::begin(entities), std::end(entities));
set.insert(std::begin(entities), std::end(entities));
set.arrange(set.begin(), set.end(), [&set, &entities](const auto lhs, const auto rhs) {
std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
@@ -476,7 +476,7 @@ TEST(SparseSet, ArrangeUnordered) {
TEST(SparseSet, ArrangeRange) {
entt::sparse_set<entt::entity> set;
entt::entity entities[5]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
set.construct(std::begin(entities), std::end(entities));
set.insert(std::begin(entities), std::end(entities));
set.arrange(set.end(), set.end(), [](const auto, const auto) { FAIL(); }, std::less{});
@@ -522,7 +522,7 @@ TEST(SparseSet, ArrangeRange) {
TEST(SparseSet, ArrangeCornerCase) {
entt::sparse_set<entt::entity> set;
entt::entity entities[5]{entt::entity{0}, entt::entity{1}, entt::entity{4}, entt::entity{3}, entt::entity{2}};
set.construct(std::begin(entities), std::end(entities));
set.insert(std::begin(entities), std::end(entities));
set.arrange(++set.begin(), set.end(), [&set, &entities](const auto lhs, const auto rhs) {
std::swap(entities[set.index(lhs)], entities[set.index(rhs)]);
@@ -545,9 +545,9 @@ TEST(SparseSet, RespectDisjoint) {
entt::sparse_set<entt::entity> lhs;
entt::sparse_set<entt::entity> rhs;
lhs.construct(entt::entity{3});
lhs.construct(entt::entity{12});
lhs.construct(entt::entity{42});
lhs.emplace(entt::entity{3});
lhs.emplace(entt::entity{12});
lhs.emplace(entt::entity{42});
ASSERT_EQ(lhs.index(entt::entity{3}), 0u);
ASSERT_EQ(lhs.index(entt::entity{12}), 1u);
@@ -564,11 +564,11 @@ TEST(SparseSet, RespectOverlap) {
entt::sparse_set<entt::entity> lhs;
entt::sparse_set<entt::entity> rhs;
lhs.construct(entt::entity{3});
lhs.construct(entt::entity{12});
lhs.construct(entt::entity{42});
lhs.emplace(entt::entity{3});
lhs.emplace(entt::entity{12});
lhs.emplace(entt::entity{42});
rhs.construct(entt::entity{12});
rhs.emplace(entt::entity{12});
ASSERT_EQ(lhs.index(entt::entity{3}), 0u);
ASSERT_EQ(lhs.index(entt::entity{12}), 1u);
@@ -585,11 +585,11 @@ TEST(SparseSet, RespectOrdered) {
entt::sparse_set<entt::entity> lhs;
entt::sparse_set<entt::entity> rhs;
lhs.construct(entt::entity{1});
lhs.construct(entt::entity{2});
lhs.construct(entt::entity{3});
lhs.construct(entt::entity{4});
lhs.construct(entt::entity{5});
lhs.emplace(entt::entity{1});
lhs.emplace(entt::entity{2});
lhs.emplace(entt::entity{3});
lhs.emplace(entt::entity{4});
lhs.emplace(entt::entity{5});
ASSERT_EQ(lhs.index(entt::entity{1}), 0u);
ASSERT_EQ(lhs.index(entt::entity{2}), 1u);
@@ -597,12 +597,12 @@ TEST(SparseSet, RespectOrdered) {
ASSERT_EQ(lhs.index(entt::entity{4}), 3u);
ASSERT_EQ(lhs.index(entt::entity{5}), 4u);
rhs.construct(entt::entity{6});
rhs.construct(entt::entity{1});
rhs.construct(entt::entity{2});
rhs.construct(entt::entity{3});
rhs.construct(entt::entity{4});
rhs.construct(entt::entity{5});
rhs.emplace(entt::entity{6});
rhs.emplace(entt::entity{1});
rhs.emplace(entt::entity{2});
rhs.emplace(entt::entity{3});
rhs.emplace(entt::entity{4});
rhs.emplace(entt::entity{5});
ASSERT_EQ(rhs.index(entt::entity{6}), 0u);
ASSERT_EQ(rhs.index(entt::entity{1}), 1u);
@@ -625,11 +625,11 @@ TEST(SparseSet, RespectReverse) {
entt::sparse_set<entt::entity> lhs;
entt::sparse_set<entt::entity> rhs;
lhs.construct(entt::entity{1});
lhs.construct(entt::entity{2});
lhs.construct(entt::entity{3});
lhs.construct(entt::entity{4});
lhs.construct(entt::entity{5});
lhs.emplace(entt::entity{1});
lhs.emplace(entt::entity{2});
lhs.emplace(entt::entity{3});
lhs.emplace(entt::entity{4});
lhs.emplace(entt::entity{5});
ASSERT_EQ(lhs.index(entt::entity{1}), 0u);
ASSERT_EQ(lhs.index(entt::entity{2}), 1u);
@@ -637,12 +637,12 @@ TEST(SparseSet, RespectReverse) {
ASSERT_EQ(lhs.index(entt::entity{4}), 3u);
ASSERT_EQ(lhs.index(entt::entity{5}), 4u);
rhs.construct(entt::entity{5});
rhs.construct(entt::entity{4});
rhs.construct(entt::entity{3});
rhs.construct(entt::entity{2});
rhs.construct(entt::entity{1});
rhs.construct(entt::entity{6});
rhs.emplace(entt::entity{5});
rhs.emplace(entt::entity{4});
rhs.emplace(entt::entity{3});
rhs.emplace(entt::entity{2});
rhs.emplace(entt::entity{1});
rhs.emplace(entt::entity{6});
ASSERT_EQ(rhs.index(entt::entity{5}), 0u);
ASSERT_EQ(rhs.index(entt::entity{4}), 1u);
@@ -665,11 +665,11 @@ TEST(SparseSet, RespectUnordered) {
entt::sparse_set<entt::entity> lhs;
entt::sparse_set<entt::entity> rhs;
lhs.construct(entt::entity{1});
lhs.construct(entt::entity{2});
lhs.construct(entt::entity{3});
lhs.construct(entt::entity{4});
lhs.construct(entt::entity{5});
lhs.emplace(entt::entity{1});
lhs.emplace(entt::entity{2});
lhs.emplace(entt::entity{3});
lhs.emplace(entt::entity{4});
lhs.emplace(entt::entity{5});
ASSERT_EQ(lhs.index(entt::entity{1}), 0u);
ASSERT_EQ(lhs.index(entt::entity{2}), 1u);
@@ -677,12 +677,12 @@ TEST(SparseSet, RespectUnordered) {
ASSERT_EQ(lhs.index(entt::entity{4}), 3u);
ASSERT_EQ(lhs.index(entt::entity{5}), 4u);
rhs.construct(entt::entity{3});
rhs.construct(entt::entity{2});
rhs.construct(entt::entity{6});
rhs.construct(entt::entity{1});
rhs.construct(entt::entity{4});
rhs.construct(entt::entity{5});
rhs.emplace(entt::entity{3});
rhs.emplace(entt::entity{2});
rhs.emplace(entt::entity{6});
rhs.emplace(entt::entity{1});
rhs.emplace(entt::entity{4});
rhs.emplace(entt::entity{5});
ASSERT_EQ(rhs.index(entt::entity{3}), 0u);
ASSERT_EQ(rhs.index(entt::entity{2}), 1u);
@@ -703,7 +703,7 @@ TEST(SparseSet, RespectUnordered) {
TEST(SparseSet, CanModifyDuringIteration) {
entt::sparse_set<entt::entity> set;
set.construct(entt::entity{0});
set.emplace(entt::entity{0});
ASSERT_EQ(set.capacity(), entt::sparse_set<entt::entity>::size_type{1});

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

@@ -30,8 +30,8 @@ TEST(Storage, Functionalities) {
ASSERT_EQ(pool.size(), 0u);
ASSERT_EQ(std::as_const(pool).begin(), std::as_const(pool).end());
ASSERT_EQ(pool.begin(), pool.end());
ASSERT_FALSE(pool.has(entt::entity{0}));
ASSERT_FALSE(pool.has(entt::entity{41}));
ASSERT_FALSE(pool.contains(entt::entity{0}));
ASSERT_FALSE(pool.contains(entt::entity{41}));
pool.construct(entt::entity{41}, 3);
@@ -39,8 +39,8 @@ TEST(Storage, Functionalities) {
ASSERT_EQ(pool.size(), 1u);
ASSERT_NE(std::as_const(pool).begin(), std::as_const(pool).end());
ASSERT_NE(pool.begin(), pool.end());
ASSERT_FALSE(pool.has(entt::entity{0}));
ASSERT_TRUE(pool.has(entt::entity{41}));
ASSERT_FALSE(pool.contains(entt::entity{0}));
ASSERT_TRUE(pool.contains(entt::entity{41}));
ASSERT_EQ(pool.get(entt::entity{41}), 3);
ASSERT_EQ(*pool.try_get(entt::entity{41}), 3);
ASSERT_EQ(pool.try_get(entt::entity{99}), nullptr);
@@ -51,8 +51,8 @@ TEST(Storage, Functionalities) {
ASSERT_EQ(pool.size(), 0u);
ASSERT_EQ(std::as_const(pool).begin(), std::as_const(pool).end());
ASSERT_EQ(pool.begin(), pool.end());
ASSERT_FALSE(pool.has(entt::entity{0}));
ASSERT_FALSE(pool.has(entt::entity{41}));
ASSERT_FALSE(pool.contains(entt::entity{0}));
ASSERT_FALSE(pool.contains(entt::entity{41}));
pool.construct(entt::entity{41}, 12);
@@ -66,8 +66,8 @@ TEST(Storage, Functionalities) {
ASSERT_EQ(pool.size(), 0u);
ASSERT_EQ(std::as_const(pool).begin(), std::as_const(pool).end());
ASSERT_EQ(pool.begin(), pool.end());
ASSERT_FALSE(pool.has(entt::entity{0}));
ASSERT_FALSE(pool.has(entt::entity{41}));
ASSERT_FALSE(pool.contains(entt::entity{0}));
ASSERT_FALSE(pool.contains(entt::entity{41}));
ASSERT_EQ(pool.capacity(), 42);
@@ -84,7 +84,7 @@ TEST(Storage, EmptyType) {
entt::storage<entt::entity, empty_type> pool;
pool.construct(entt::entity{99});
ASSERT_TRUE(pool.has(entt::entity{99}));
ASSERT_TRUE(pool.contains(entt::entity{99}));
}
TEST(Storage, BatchAdd) {
@@ -95,8 +95,8 @@ TEST(Storage, BatchAdd) {
entities[1] = entt::entity{42};
pool.construct(std::begin(entities), std::end(entities), {});
ASSERT_TRUE(pool.has(entities[0]));
ASSERT_TRUE(pool.has(entities[1]));
ASSERT_TRUE(pool.contains(entities[0]));
ASSERT_TRUE(pool.contains(entities[1]));
ASSERT_FALSE(pool.empty());
ASSERT_EQ(pool.size(), 2u);
@@ -113,8 +113,8 @@ TEST(Storage, BatchAddEmptyType) {
pool.construct(std::begin(entities), std::end(entities));
ASSERT_TRUE(pool.has(entities[0]));
ASSERT_TRUE(pool.has(entities[1]));
ASSERT_TRUE(pool.contains(entities[0]));
ASSERT_TRUE(pool.contains(entities[1]));
ASSERT_FALSE(pool.empty());
ASSERT_EQ(pool.size(), 2u);