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

registry: removed deprecated functions

Browse Source
This commit is contained in:
Michele Caini
2020-05-12 00:12:49 +02:00
parent 39a15bef12
commit 7d4f10ccc6
16 changed files with 640 additions and 693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -646,13 +646,6 @@ public:
return assure<Component>().emplace(*this, entity, std::forward<Args>(args)...);
}
/*! @copydoc emplace */
template<typename Component, typename... Args>
[[deprecated("use ::emplace instead")]]
decltype(auto) assign(const entity_type entity, Args &&... args) {
return emplace<Component>(entity, std::forward<Args>(args)...);
}
/**
* @brief Assigns each entity in a range the given component.
*
@@ -670,14 +663,6 @@ public:
assure<Component>().insert(*this, first, last, value);
}
/*! @copydoc insert */
template<typename Component, typename It>
[[deprecated("use ::insert instead")]]
std::enable_if_t<std::is_same_v<typename std::iterator_traits<It>::value_type, entity_type>, void>
assign(It first, It last, const Component &value = {}) {
return insert(std::move(first), std::move(last), value);
}
/**
* @brief Assigns each entity in a range the given components.
*
@@ -698,14 +683,6 @@ public:
assure<Component>().insert(*this, first, last, from, to);
}
/*! @copydoc insert */
template<typename Component, typename EIt, typename CIt>
[[deprecated("use ::insert instead")]]
std::enable_if_t<std::is_same_v<typename std::iterator_traits<EIt>::value_type, entity_type>, void>
assign(EIt first, EIt last, CIt value) {
return insert<Component>(std::move(first), std::move(last), value, value + std::distance(first, last));
}
/**
* @brief Assigns or replaces the given component for an entity.
*
@@ -738,13 +715,6 @@ public:
: cpool.emplace(*this, entity, std::forward<Args>(args)...);
}
/*! @copydoc emplace_or_replace */
template<typename Component, typename... Args>
[[deprecated("use ::emplace_or_replace instead")]]
decltype(auto) assign_or_replace(const entity_type entity, Args &&... args) {
return emplace_or_replace<Component>(entity, std::forward<Args>(args)...);
}
/**
* @brief Patches the given component for an entity.
*
@@ -778,14 +748,6 @@ public:
return assure<Component>().patch(*this, entity, std::forward<Func>(func)...);
}
/*! @copydoc patch */
template<typename Component, typename... Func>
[[deprecated("use registry::patch instead")]]
auto replace(const entity_type entity, Func &&... func)
-> decltype((func(std::declval<Component &>()), ...), assign<Component>(entity)) {
return patch<Component>(entity, std::forward<Func>(func)...);
}
/**
* @brief Replaces the given component for an entity.
*
@@ -807,8 +769,7 @@ public:
* @return A reference to the component being replaced.
*/
template<typename Component, typename... Args>
auto replace(const entity_type entity, Args &&... args)
-> decltype(std::enable_if_t<sizeof...(Args) != 0>(), Component{std::forward<Args>(args)...}, assure<Component>().get(entity)) {
decltype(auto) replace(const entity_type entity, Args &&... args) {
return assure<Component>().replace(*this, entity, Component{std::forward<Args>(args)...});
}
@@ -1009,13 +970,6 @@ public:
return cpool.contains(entity) ? cpool.get(entity) : cpool.emplace(*this, entity, std::forward<Args>(args)...);
}
/*! @copydoc get_or_emplace */
template<typename Component, typename... Args>
[[deprecated("use ::get_or_emplace instead")]]
decltype(auto) get_or_assign(const entity_type entity, Args &&... args) {
return get_or_emplace<Component>(entity, std::forward<Args>(args)...);
}
/**
* @brief Returns pointers to the given components for an entity.
*
@@ -1190,13 +1144,6 @@ public:
return assure<Component>().on_update();
}
/*! @copydoc on_update */
template<typename Component>
[[deprecated("use registry::on_update instead")]]
auto on_replace() {
return on_update<Component>();
}
/**
* @brief Returns a sink object for the given component.
*

232
test/benchmark/benchmark.cpp
View File

@@ -38,9 +38,9 @@ void pathological(Func func) {
for(std::uint64_t i = 0; i < 500000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
for(auto i = 0; i < 10; ++i) {
@@ -53,9 +53,9 @@ void pathological(Func func) {
for(std::uint64_t j = 0; j < 50000L; j++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
}
@@ -89,19 +89,19 @@ TEST(Benchmark, CreateMany) {
timer.elapsed();
}
TEST(Benchmark, CreateManyAndAssignComponents) {
TEST(Benchmark, CreateManyAndEmplaceComponents) {
entt::registry registry;
std::vector<entt::entity> entities(1000000);
std::cout << "Creating 1000000 entities at once and assign components" << std::endl;
std::cout << "Creating 1000000 entities at once and emplace components" << std::endl;
timer timer;
registry.create(entities.begin(), entities.end());
for(const auto entity: entities) {
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
timer.elapsed();
@@ -115,8 +115,8 @@ TEST(Benchmark, CreateManyWithComponents) {
timer timer;
registry.create(entities.begin(), entities.end());
registry.assign<position>(entities.begin(), entities.end());
registry.assign<velocity>(entities.begin(), entities.end());
registry.insert<position>(entities.begin(), entities.end());
registry.insert<velocity>(entities.begin(), entities.end());
timer.elapsed();
}
@@ -145,7 +145,7 @@ TEST(Benchmark, IterateSingleComponent1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
auto test = [&registry](auto func) {
@@ -166,7 +166,7 @@ TEST(Benchmark, IterateSingleComponentRuntime1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
auto test = [&registry](auto func) {
@@ -189,8 +189,8 @@ TEST(Benchmark, IterateTwoComponents1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
auto test = [&registry](auto func) {
@@ -211,10 +211,10 @@ TEST(Benchmark, IterateTwoComponents1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.emplace<velocity>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -236,10 +236,10 @@ TEST(Benchmark, IterateTwoComponents1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.emplace<velocity>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -262,8 +262,8 @@ TEST(Benchmark, IterateTwoComponentsNonOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
auto test = [&registry](auto func) {
@@ -285,8 +285,8 @@ TEST(Benchmark, IterateTwoComponentsFullOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
auto test = [&registry](auto func) {
@@ -308,8 +308,8 @@ TEST(Benchmark, IterateTwoComponentsPartialOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
auto test = [&registry](auto func) {
@@ -330,8 +330,8 @@ TEST(Benchmark, IterateTwoComponentsRuntime1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
}
auto test = [&registry](auto func) {
@@ -358,10 +358,10 @@ TEST(Benchmark, IterateTwoComponentsRuntime1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.emplace<velocity>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -389,10 +389,10 @@ TEST(Benchmark, IterateTwoComponentsRuntime1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.emplace<velocity>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -420,9 +420,9 @@ TEST(Benchmark, IterateThreeComponents1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
auto test = [&registry](auto func) {
@@ -443,11 +443,11 @@ TEST(Benchmark, IterateThreeComponents1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -469,11 +469,11 @@ TEST(Benchmark, IterateThreeComponents1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -496,9 +496,9 @@ TEST(Benchmark, IterateThreeComponentsNonOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
auto test = [&registry](auto func) {
@@ -520,9 +520,9 @@ TEST(Benchmark, IterateThreeComponentsFullOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
auto test = [&registry](auto func) {
@@ -544,9 +544,9 @@ TEST(Benchmark, IterateThreeComponentsPartialOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
auto test = [&registry](auto func) {
@@ -567,9 +567,9 @@ TEST(Benchmark, IterateThreeComponentsRuntime1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
}
auto test = [&registry](auto func) {
@@ -598,11 +598,11 @@ TEST(Benchmark, IterateThreeComponentsRuntime1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -632,11 +632,11 @@ TEST(Benchmark, IterateThreeComponentsRuntime1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -666,11 +666,11 @@ TEST(Benchmark, IterateFiveComponents1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -691,13 +691,13 @@ TEST(Benchmark, IterateFiveComponents1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -719,13 +719,13 @@ TEST(Benchmark, IterateFiveComponents1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -748,11 +748,11 @@ TEST(Benchmark, IterateFiveComponentsNonOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -774,11 +774,11 @@ TEST(Benchmark, IterateFiveComponentsFullOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -800,11 +800,11 @@ TEST(Benchmark, IterateFiveComponentsPartialFourOfFiveOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -826,11 +826,11 @@ TEST(Benchmark, IterateFiveComponentsPartialThreeOfFiveOwningGroup1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -851,11 +851,11 @@ TEST(Benchmark, IterateFiveComponentsRuntime1M) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity);
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<position>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
}
auto test = [&registry](auto func) {
@@ -888,13 +888,13 @@ TEST(Benchmark, IterateFiveComponentsRuntime1MHalf) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
if(i % 2) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -928,13 +928,13 @@ TEST(Benchmark, IterateFiveComponentsRuntime1MOne) {
for(std::uint64_t i = 0; i < 1000000L; i++) {
const auto entity = registry.create();
registry.assign<velocity>(entity);
registry.assign<comp<0>>(entity);
registry.assign<comp<1>>(entity);
registry.assign<comp<2>>(entity);
registry.emplace<velocity>(entity);
registry.emplace<comp<0>>(entity);
registry.emplace<comp<1>>(entity);
registry.emplace<comp<2>>(entity);
if(i == 500000L) {
registry.assign<position>(entity);
registry.emplace<position>(entity);
}
}
@@ -1014,7 +1014,7 @@ TEST(Benchmark, SortSingle) {
for(std::uint64_t i = 0; i < 150000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.emplace<position>(entity, i, i);
}
timer timer;
@@ -1033,8 +1033,8 @@ TEST(Benchmark, SortMulti) {
for(std::uint64_t i = 0; i < 150000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.assign<velocity>(entity, i, i);
registry.emplace<position>(entity, i, i);
registry.emplace<velocity>(entity, i, i);
}
registry.sort<position>([](const auto &lhs, const auto &rhs) {
@@ -1056,7 +1056,7 @@ TEST(Benchmark, AlmostSortedStdSort) {
for(std::uint64_t i = 0; i < 150000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.emplace<position>(entity, i, i);
if(!(i % 50000)) {
entities[i / 50000] = entity;
@@ -1066,7 +1066,7 @@ TEST(Benchmark, AlmostSortedStdSort) {
for(std::uint64_t i = 0; i < 3; ++i) {
registry.destroy(entities[i]);
const auto entity = registry.create();
registry.assign<position>(entity, 50000 * i, 50000 * i);
registry.emplace<position>(entity, 50000 * i, 50000 * i);
}
timer timer;
@@ -1086,7 +1086,7 @@ TEST(Benchmark, AlmostSortedInsertionSort) {
for(std::uint64_t i = 0; i < 150000L; i++) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.emplace<position>(entity, i, i);
if(!(i % 50000)) {
entities[i / 50000] = entity;
@@ -1096,7 +1096,7 @@ TEST(Benchmark, AlmostSortedInsertionSort) {
for(std::uint64_t i = 0; i < 3; ++i) {
registry.destroy(entities[i]);
const auto entity = registry.create();
registry.assign<position>(entity, 50000 * i, 50000 * i);
registry.emplace<position>(entity, 50000 * i, 50000 * i);
}
timer timer;

4
test/entt/entity/actor.cpp
View File

@@ -43,8 +43,8 @@ TEST(Actor, FromEntity) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity, 42);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 42);
registry.emplace<char>(entity, 'c');
entt::actor actor{entity, registry};

2
test/entt/entity/entity.cpp
View File

@@ -10,7 +10,7 @@ TEST(Entity, Null) {
entt::registry registry{};
const auto entity = registry.create();
registry.assign<int>(entity, 42);
registry.emplace<int>(entity, 42);
ASSERT_FALSE(entt::entity{} == entt::null);
ASSERT_TRUE(entt::entity{traits_type::entity_mask} == entt::null);

362
test/entt/entity/group.cpp
View File

@@ -24,11 +24,11 @@ TEST(NonOwningGroup, Functionalities) {
ASSERT_TRUE((cgroup.empty<const int, const char>()));
const auto e0 = registry.create();
registry.assign<char>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
ASSERT_FALSE(group.empty());
ASSERT_FALSE((group.empty<int>()));
@@ -42,7 +42,7 @@ TEST(NonOwningGroup, Functionalities) {
ASSERT_EQ(group.size<int>(), typename decltype(group)::size_type{1});
ASSERT_EQ(cgroup.size<const char>(), typename decltype(group)::size_type{2});
registry.assign<int>(e0);
registry.emplace<int>(e0);
ASSERT_EQ(group.size(), typename decltype(group)::size_type{2});
ASSERT_EQ(group.size<int>(), typename decltype(group)::size_type{2});
@@ -94,12 +94,12 @@ TEST(NonOwningGroup, ElementAccess) {
auto cgroup = std::as_const(registry).group(entt::get<const int, const char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
for(typename decltype(group)::size_type i{}; i < group.size(); ++i) {
ASSERT_EQ(group[i], i ? e0 : e1);
@@ -112,12 +112,12 @@ TEST(NonOwningGroup, Contains) {
auto group = registry.group(entt::get<int, char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.destroy(e0);
@@ -129,13 +129,13 @@ TEST(NonOwningGroup, Empty) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<double>(e0);
registry.assign<int>(e0);
registry.assign<float>(e0);
registry.emplace<double>(e0);
registry.emplace<int>(e0);
registry.emplace<float>(e0);
const auto e1 = registry.create();
registry.assign<char>(e1);
registry.assign<float>(e1);
registry.emplace<char>(e1);
registry.emplace<float>(e1);
ASSERT_TRUE(registry.group(entt::get<char, int, float>).empty());
ASSERT_TRUE(registry.group(entt::get<double, char, int, float>).empty());
@@ -146,12 +146,12 @@ TEST(NonOwningGroup, Each) {
auto group = registry.group(entt::get<int, char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
auto cgroup = std::as_const(registry).group(entt::get<const int, const char>);
std::size_t cnt = 0;
@@ -176,14 +176,14 @@ TEST(NonOwningGroup, Sort) {
const auto e2 = registry.create();
const auto e3 = registry.create();
registry.assign<unsigned int>(e0, 0u);
registry.assign<unsigned int>(e1, 1u);
registry.assign<unsigned int>(e2, 2u);
registry.assign<unsigned int>(e3, 3u);
registry.emplace<unsigned int>(e0, 0u);
registry.emplace<unsigned int>(e1, 1u);
registry.emplace<unsigned int>(e2, 2u);
registry.emplace<unsigned int>(e3, 3u);
registry.assign<int>(e0, 0);
registry.assign<int>(e1, 1);
registry.assign<int>(e2, 2);
registry.emplace<int>(e0, 0);
registry.emplace<int>(e1, 1);
registry.emplace<int>(e2, 2);
ASSERT_EQ(*(group.raw<unsigned int>() + 0u), 0u);
ASSERT_EQ(*(group.raw<unsigned int>() + 1u), 1u);
@@ -246,14 +246,14 @@ TEST(NonOwningGroup, SortAsAPool) {
auto uval = 0u;
auto ival = 0;
registry.assign<unsigned int>(e0, uval++);
registry.assign<unsigned int>(e1, uval++);
registry.assign<unsigned int>(e2, uval++);
registry.assign<unsigned int>(e3, uval+1);
registry.emplace<unsigned int>(e0, uval++);
registry.emplace<unsigned int>(e1, uval++);
registry.emplace<unsigned int>(e2, uval++);
registry.emplace<unsigned int>(e3, uval+1);
registry.assign<int>(e0, ival++);
registry.assign<int>(e1, ival++);
registry.assign<int>(e2, ival++);
registry.emplace<int>(e0, ival++);
registry.emplace<int>(e1, ival++);
registry.emplace<int>(e2, ival++);
for(auto entity: group) {
ASSERT_EQ(group.get<unsigned int>(entity), --uval);
@@ -282,14 +282,14 @@ TEST(NonOwningGroup, IndexRebuiltOnDestroy) {
const auto e0 = registry.create();
const auto e1 = registry.create();
registry.assign<unsigned int>(e0, 0u);
registry.assign<unsigned int>(e1, 1u);
registry.emplace<unsigned int>(e0, 0u);
registry.emplace<unsigned int>(e1, 1u);
registry.assign<int>(e0, 0);
registry.assign<int>(e1, 1);
registry.emplace<int>(e0, 0);
registry.emplace<int>(e1, 1);
registry.destroy(e0);
registry.assign<int>(registry.create(), 42);
registry.emplace<int>(registry.create(), 42);
ASSERT_EQ(group.size(), typename decltype(group)::size_type{1});
ASSERT_EQ(group[{}], e1);
@@ -310,8 +310,8 @@ TEST(NonOwningGroup, ConstNonConstAndAllInBetween) {
ASSERT_EQ(group.size(), decltype(group.size()){0});
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), decltype(group.size()){1});
@@ -332,20 +332,20 @@ TEST(NonOwningGroup, Find) {
auto group = registry.group(entt::get<int, const char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto e2 = registry.create();
registry.assign<int>(e2);
registry.assign<char>(e2);
registry.emplace<int>(e2);
registry.emplace<char>(e2);
const auto e3 = registry.create();
registry.assign<int>(e3);
registry.assign<char>(e3);
registry.emplace<int>(e3);
registry.emplace<char>(e3);
registry.remove<int>(e1);
@@ -365,8 +365,8 @@ TEST(NonOwningGroup, Find) {
const auto e4 = registry.create();
registry.destroy(e4);
const auto e5 = registry.create();
registry.assign<int>(e5);
registry.assign<char>(e5);
registry.emplace<int>(e5);
registry.emplace<char>(e5);
ASSERT_NE(group.find(e5), group.end());
ASSERT_EQ(group.find(e4), group.end());
@@ -376,20 +376,20 @@ TEST(NonOwningGroup, ExcludedComponents) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0, 0);
registry.emplace<int>(e0, 0);
const auto e1 = registry.create();
registry.assign<int>(e1, 1);
registry.assign<char>(e1);
registry.emplace<int>(e1, 1);
registry.emplace<char>(e1);
const auto group = registry.group(entt::get<int>, entt::exclude<char>);
const auto e2 = registry.create();
registry.assign<int>(e2, 2);
registry.emplace<int>(e2, 2);
const auto e3 = registry.create();
registry.assign<int>(e3, 3);
registry.assign<char>(e3);
registry.emplace<int>(e3, 3);
registry.emplace<char>(e3);
for(const auto entity: group) {
ASSERT_TRUE(entity == e0 || entity == e2);
@@ -401,8 +401,8 @@ TEST(NonOwningGroup, ExcludedComponents) {
}
}
registry.assign<char>(e0);
registry.assign<char>(e2);
registry.emplace<char>(e0);
registry.emplace<char>(e2);
ASSERT_TRUE(group.empty());
@@ -425,14 +425,14 @@ TEST(NonOwningGroup, EmptyAndNonEmptyTypes) {
const auto group = registry.group(entt::get<int, empty_type>);
const auto e0 = registry.create();
registry.assign<empty_type>(e0);
registry.assign<int>(e0);
registry.emplace<empty_type>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<empty_type>(e1);
registry.assign<int>(e1);
registry.emplace<empty_type>(e1);
registry.emplace<int>(e1);
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
for(const auto entity: group) {
ASSERT_TRUE(entity == e0 || entity == e1);
@@ -451,8 +451,8 @@ TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
const auto cgroup = std::as_const(registry).group(entt::get<const int>, entt::exclude<char>);
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(group.empty());
ASSERT_TRUE(cgroup.empty());
@@ -467,9 +467,9 @@ TEST(NonOwningGroup, Less) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.assign<entt::tag<"empty"_hs>>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
registry.emplace<entt::tag<"empty"_hs>>(entity);
registry.group(entt::get<int, char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
ASSERT_EQ(entity, entt);
@@ -495,15 +495,15 @@ TEST(NonOwningGroup, FrontBack) {
ASSERT_EQ(group.back(), static_cast<entt::entity>(entt::null));
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto entity = registry.create();
registry.assign<char>(entity);
registry.emplace<char>(entity);
ASSERT_EQ(group.front(), e1);
ASSERT_EQ(group.back(), e0);
@@ -511,11 +511,11 @@ TEST(NonOwningGroup, FrontBack) {
TEST(NonOwningGroup, SignalRace) {
entt::registry registry;
registry.on_construct<double>().connect<&entt::registry::assign_or_replace<int>>();
registry.on_construct<double>().connect<&entt::registry::emplace_or_replace<int>>();
registry.group(entt::get<int, double>);
auto entity = registry.create();
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_EQ(registry.group(entt::get<int, double>).size(), 1u);
}
@@ -530,11 +530,11 @@ TEST(OwningGroup, Functionalities) {
ASSERT_TRUE((cgroup.empty<const int, const char>()));
const auto e0 = registry.create();
registry.assign<char>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
ASSERT_FALSE(group.empty());
ASSERT_FALSE((group.empty<int>()));
@@ -548,7 +548,7 @@ TEST(OwningGroup, Functionalities) {
ASSERT_EQ(group.size<int>(), typename decltype(group)::size_type{1});
ASSERT_EQ(cgroup.size<const char>(), typename decltype(group)::size_type{2});
registry.assign<int>(e0);
registry.emplace<int>(e0);
ASSERT_EQ(group.size(), typename decltype(group)::size_type{2});
ASSERT_EQ(group.size<int>(), typename decltype(group)::size_type{2});
@@ -597,12 +597,12 @@ TEST(OwningGroup, ElementAccess) {
auto cgroup = std::as_const(registry).group<const int>(entt::get<const char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
for(typename decltype(group)::size_type i{}; i < group.size(); ++i) {
ASSERT_EQ(group[i], i ? e0 : e1);
@@ -615,12 +615,12 @@ TEST(OwningGroup, Contains) {
auto group = registry.group<int>(entt::get<char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.destroy(e0);
@@ -632,13 +632,13 @@ TEST(OwningGroup, Empty) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<double>(e0);
registry.assign<int>(e0);
registry.assign<float>(e0);
registry.emplace<double>(e0);
registry.emplace<int>(e0);
registry.emplace<float>(e0);
const auto e1 = registry.create();
registry.assign<char>(e1);
registry.assign<float>(e1);
registry.emplace<char>(e1);
registry.emplace<float>(e1);
ASSERT_TRUE((registry.group<char, int>(entt::get<float>).empty()));
ASSERT_TRUE((registry.group<double, float>(entt::get<char, int>).empty()));
@@ -649,12 +649,12 @@ TEST(OwningGroup, Each) {
auto group = registry.group<int>(entt::get<char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
auto cgroup = std::as_const(registry).group<const int>(entt::get<const char>);
std::size_t cnt = 0;
@@ -677,17 +677,17 @@ TEST(OwningGroup, SortOrdered) {
entt::entity entities[5]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 12);
registry.assign<char>(entities[0], 'a');
registry.emplace<boxed_int>(entities[0], 12);
registry.emplace<char>(entities[0], 'a');
registry.assign<boxed_int>(entities[1], 9);
registry.assign<char>(entities[1], 'b');
registry.emplace<boxed_int>(entities[1], 9);
registry.emplace<char>(entities[1], 'b');
registry.assign<boxed_int>(entities[2], 6);
registry.assign<char>(entities[2], 'c');
registry.emplace<boxed_int>(entities[2], 6);
registry.emplace<char>(entities[2], 'c');
registry.assign<boxed_int>(entities[3], 1);
registry.assign<boxed_int>(entities[4], 2);
registry.emplace<boxed_int>(entities[3], 1);
registry.emplace<boxed_int>(entities[4], 2);
group.sort([&group](const entt::entity lhs, const entt::entity rhs) {
return group.get<boxed_int>(lhs).value < group.get<boxed_int>(rhs).value;
@@ -724,17 +724,17 @@ TEST(OwningGroup, SortReverse) {
entt::entity entities[5]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 6);
registry.assign<char>(entities[0], 'a');
registry.emplace<boxed_int>(entities[0], 6);
registry.emplace<char>(entities[0], 'a');
registry.assign<boxed_int>(entities[1], 9);
registry.assign<char>(entities[1], 'b');
registry.emplace<boxed_int>(entities[1], 9);
registry.emplace<char>(entities[1], 'b');
registry.assign<boxed_int>(entities[2], 12);
registry.assign<char>(entities[2], 'c');
registry.emplace<boxed_int>(entities[2], 12);
registry.emplace<char>(entities[2], 'c');
registry.assign<boxed_int>(entities[3], 1);
registry.assign<boxed_int>(entities[4], 2);
registry.emplace<boxed_int>(entities[3], 1);
registry.emplace<boxed_int>(entities[4], 2);
group.sort<boxed_int>([](const auto &lhs, const auto &rhs) {
return lhs.value < rhs.value;
@@ -771,23 +771,23 @@ TEST(OwningGroup, SortUnordered) {
entt::entity entities[7]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 6);
registry.assign<char>(entities[0], 'c');
registry.emplace<boxed_int>(entities[0], 6);
registry.emplace<char>(entities[0], 'c');
registry.assign<boxed_int>(entities[1], 3);
registry.assign<char>(entities[1], 'b');
registry.emplace<boxed_int>(entities[1], 3);
registry.emplace<char>(entities[1], 'b');
registry.assign<boxed_int>(entities[2], 1);
registry.assign<char>(entities[2], 'a');
registry.emplace<boxed_int>(entities[2], 1);
registry.emplace<char>(entities[2], 'a');
registry.assign<boxed_int>(entities[3], 9);
registry.assign<char>(entities[3], 'd');
registry.emplace<boxed_int>(entities[3], 9);
registry.emplace<char>(entities[3], 'd');
registry.assign<boxed_int>(entities[4], 12);
registry.assign<char>(entities[4], 'e');
registry.emplace<boxed_int>(entities[4], 12);
registry.emplace<char>(entities[4], 'e');
registry.assign<boxed_int>(entities[5], 4);
registry.assign<boxed_int>(entities[6], 5);
registry.emplace<boxed_int>(entities[5], 4);
registry.emplace<boxed_int>(entities[6], 5);
group.sort<char>([](const auto lhs, const auto rhs) {
return lhs < rhs;
@@ -832,13 +832,13 @@ TEST(OwningGroup, SortWithExclusionList) {
entt::entity entities[5]{};
registry.create(std::begin(entities), std::end(entities));
registry.assign<boxed_int>(entities[0], 0);
registry.assign<boxed_int>(entities[1], 1);
registry.assign<boxed_int>(entities[2], 2);
registry.assign<boxed_int>(entities[3], 3);
registry.assign<boxed_int>(entities[4], 4);
registry.emplace<boxed_int>(entities[0], 0);
registry.emplace<boxed_int>(entities[1], 1);
registry.emplace<boxed_int>(entities[2], 2);
registry.emplace<boxed_int>(entities[3], 3);
registry.emplace<boxed_int>(entities[4], 4);
registry.assign<char>(entities[2]);
registry.emplace<char>(entities[2]);
group.sort([](const entt::entity lhs, const entt::entity rhs) {
return lhs < rhs;
@@ -869,14 +869,14 @@ TEST(OwningGroup, IndexRebuiltOnDestroy) {
const auto e0 = registry.create();
const auto e1 = registry.create();
registry.assign<unsigned int>(e0, 0u);
registry.assign<unsigned int>(e1, 1u);
registry.emplace<unsigned int>(e0, 0u);
registry.emplace<unsigned int>(e1, 1u);
registry.assign<int>(e0, 0);
registry.assign<int>(e1, 1);
registry.emplace<int>(e0, 0);
registry.emplace<int>(e1, 1);
registry.destroy(e0);
registry.assign<int>(registry.create(), 42);
registry.emplace<int>(registry.create(), 42);
ASSERT_EQ(group.size(), typename decltype(group)::size_type{1});
ASSERT_EQ(group[{}], e1);
@@ -897,10 +897,10 @@ TEST(OwningGroup, ConstNonConstAndAllInBetween) {
ASSERT_EQ(group.size(), decltype(group.size()){0});
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.assign<double>(entity, 0.);
registry.assign<float>(entity, 0.f);
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
registry.emplace<double>(entity, 0.);
registry.emplace<float>(entity, 0.f);
ASSERT_EQ(group.size(), decltype(group.size()){1});
@@ -927,20 +927,20 @@ TEST(OwningGroup, Find) {
auto group = registry.group<int>(entt::get<const char>);
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto e2 = registry.create();
registry.assign<int>(e2);
registry.assign<char>(e2);
registry.emplace<int>(e2);
registry.emplace<char>(e2);
const auto e3 = registry.create();
registry.assign<int>(e3);
registry.assign<char>(e3);
registry.emplace<int>(e3);
registry.emplace<char>(e3);
registry.remove<int>(e1);
@@ -960,8 +960,8 @@ TEST(OwningGroup, Find) {
const auto e4 = registry.create();
registry.destroy(e4);
const auto e5 = registry.create();
registry.assign<int>(e5);
registry.assign<char>(e5);
registry.emplace<int>(e5);
registry.emplace<char>(e5);
ASSERT_NE(group.find(e5), group.end());
ASSERT_EQ(group.find(e4), group.end());
@@ -971,20 +971,20 @@ TEST(OwningGroup, ExcludedComponents) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0, 0);
registry.emplace<int>(e0, 0);
const auto e1 = registry.create();
registry.assign<int>(e1, 1);
registry.assign<char>(e1);
registry.emplace<int>(e1, 1);
registry.emplace<char>(e1);
const auto group = registry.group<int>(entt::exclude<char, double>);
const auto e2 = registry.create();
registry.assign<int>(e2, 2);
registry.emplace<int>(e2, 2);
const auto e3 = registry.create();
registry.assign<int>(e3, 3);
registry.assign<double>(e3);
registry.emplace<int>(e3, 3);
registry.emplace<double>(e3);
for(const auto entity: group) {
ASSERT_TRUE(entity == e0 || entity == e2);
@@ -996,8 +996,8 @@ TEST(OwningGroup, ExcludedComponents) {
}
}
registry.assign<char>(e0);
registry.assign<double>(e2);
registry.emplace<char>(e0);
registry.emplace<double>(e2);
ASSERT_TRUE(group.empty());
@@ -1020,14 +1020,14 @@ TEST(OwningGroup, EmptyAndNonEmptyTypes) {
const auto group = registry.group<int>(entt::get<empty_type>);
const auto e0 = registry.create();
registry.assign<empty_type>(e0);
registry.assign<int>(e0);
registry.emplace<empty_type>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<empty_type>(e1);
registry.assign<int>(e1);
registry.emplace<empty_type>(e1);
registry.emplace<int>(e1);
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
for(const auto entity: group) {
ASSERT_TRUE(entity == e0 || entity == e1);
@@ -1046,8 +1046,8 @@ TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
const auto cgroup = std::as_const(registry).group<const int>(entt::exclude<char>);
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(group.empty());
ASSERT_TRUE(cgroup.empty());
@@ -1062,9 +1062,9 @@ TEST(OwningGroup, Less) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.assign<entt::tag<"empty"_hs>>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
registry.emplace<entt::tag<"empty"_hs>>(entity);
registry.group<int>(entt::get<char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
ASSERT_EQ(entity, entt);
@@ -1090,15 +1090,15 @@ TEST(OwningGroup, FrontBack) {
ASSERT_EQ(group.back(), static_cast<entt::entity>(entt::null));
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto entity = registry.create();
registry.assign<char>(entity);
registry.emplace<char>(entity);
ASSERT_EQ(group.front(), e1);
ASSERT_EQ(group.back(), e0);
@@ -1106,11 +1106,11 @@ TEST(OwningGroup, FrontBack) {
TEST(OwningGroup, SignalRace) {
entt::registry registry;
registry.on_construct<double>().connect<&entt::registry::assign_or_replace<int>>();
registry.on_construct<double>().connect<&entt::registry::emplace_or_replace<int>>();
registry.group<int>(entt::get<double>);
auto entity = registry.create();
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_EQ(registry.group<int>(entt::get<double>).size(), 1u);
}
@@ -1120,8 +1120,8 @@ TEST(OwningGroup, StableLateInitialization) {
for(std::size_t i{}; i < 30u; ++i) {
auto entity = registry.create();
if(!(i % 2u)) registry.assign<int>(entity);
if(!(i % 3u)) registry.assign<char>(entity);
if(!(i % 2u)) registry.emplace<int>(entity);
if(!(i % 3u)) registry.emplace<char>(entity);
}
// thanks to @pgruenbacher for pointing out this corner case
@@ -1131,11 +1131,11 @@ TEST(OwningGroup, StableLateInitialization) {
TEST(OwningGroup, PreventEarlyOptOut) {
entt::registry registry;
registry.assign<int>(registry.create(), 3);
registry.emplace<int>(registry.create(), 3);
const auto entity = registry.create();
registry.assign<char>(entity, 'c');
registry.assign<int>(entity, 2);
registry.emplace<char>(entity, 'c');
registry.emplace<int>(entity, 2);
// thanks to @pgruenbacher for pointing out this corner case
registry.group<char, int>().each([entity](const auto entt, const auto &c, const auto &i) {

2
test/entt/entity/helper.cpp
View File

@@ -34,7 +34,7 @@ TEST(Invoke, MemberFunction) {
const auto entity = registry.create();
registry.on_construct<clazz>().connect<entt::invoke<&clazz::func>>();
registry.assign<clazz>(entity);
registry.emplace<clazz>(entity);
ASSERT_EQ(entity, registry.get<clazz>(entity).entt);
}

86
test/entt/entity/observer.cpp
View File

@@ -15,7 +15,7 @@ TEST(Observer, Functionalities) {
ASSERT_EQ(observer.begin(), observer.end());
const auto entity = registry.create();
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
@@ -32,7 +32,7 @@ TEST(Observer, Functionalities) {
observer.disconnect();
registry.remove<int>(entity);
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
@@ -49,14 +49,14 @@ TEST(Observer, AllOf) {
ASSERT_TRUE(observer.empty());
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_FALSE(observer.empty());
@@ -64,8 +64,8 @@ TEST(Observer, AllOf) {
ASSERT_TRUE(observer.empty());
registry.assign<float>(entity);
registry.assign<int>(entity);
registry.emplace<float>(entity);
registry.emplace<int>(entity);
ASSERT_FALSE(observer.empty());
@@ -73,14 +73,14 @@ TEST(Observer, AllOf) {
ASSERT_TRUE(observer.empty());
registry.assign<double>(entity);
registry.emplace<double>(entity);
observer.clear();
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.assign_or_replace<int>(entity);
registry.assign_or_replace<char>(entity);
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
registry.remove_if_exists<float>(entity);
ASSERT_TRUE(observer.empty());
@@ -96,28 +96,28 @@ TEST(Observer, AllOfFiltered) {
ASSERT_TRUE(observer.empty());
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
ASSERT_EQ(observer.data(), nullptr);
registry.remove<int>(entity);
registry.assign<char>(entity);
registry.assign<double>(entity);
registry.assign<int>(entity);
registry.emplace<char>(entity);
registry.emplace<double>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE(observer.empty());
registry.remove<int>(entity);
registry.remove<double>(entity);
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
@@ -127,7 +127,7 @@ TEST(Observer, AllOfFiltered) {
observer.disconnect();
registry.remove<int>(entity);
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE(observer.empty());
}
@@ -139,12 +139,12 @@ TEST(Observer, Observe) {
ASSERT_TRUE(observer.empty());
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<int>(entity);
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
@@ -160,8 +160,8 @@ TEST(Observer, Observe) {
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.assign_or_replace<int>(entity);
registry.assign_or_replace<char>(entity);
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
ASSERT_TRUE(observer.empty());
}
@@ -176,15 +176,15 @@ TEST(Observer, ObserveFiltered) {
ASSERT_TRUE(observer.empty());
registry.assign<int>(entity);
registry.emplace<int>(entity);
registry.replace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
ASSERT_EQ(observer.data(), nullptr);
registry.assign<char>(entity);
registry.assign<double>(entity);
registry.emplace<char>(entity);
registry.emplace<double>(entity);
registry.replace<int>(entity);
ASSERT_TRUE(observer.empty());
@@ -196,7 +196,7 @@ TEST(Observer, ObserveFiltered) {
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
@@ -219,8 +219,8 @@ TEST(Observer, AllOfObserve) {
ASSERT_TRUE(observer.empty());
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
registry.replace<char>(entity);
registry.remove<int>(entity);
@@ -229,7 +229,7 @@ TEST(Observer, AllOfObserve) {
ASSERT_EQ(*observer.data(), entity);
registry.remove<char>(entity);
registry.assign<char>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
@@ -239,8 +239,8 @@ TEST(Observer, AllOfObserve) {
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.assign_or_replace<int>(entity);
registry.assign_or_replace<char>(entity);
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
ASSERT_TRUE(observer.empty());
}
@@ -250,12 +250,12 @@ TEST(Observer, CrossRulesCornerCase) {
entt::observer observer{registry, entt::collector.group<int>().group<char>()};
const auto entity = registry.create();
registry.assign<int>(entity);
registry.emplace<int>(entity);
observer.clear();
ASSERT_TRUE(observer.empty());
registry.assign<char>(entity);
registry.emplace<char>(entity);
registry.remove<int>(entity);
ASSERT_FALSE(observer.empty());
@@ -265,7 +265,7 @@ TEST(Observer, Each) {
entt::registry registry;
entt::observer observer{registry, entt::collector.group<int>()};
const auto entity = registry.create();
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(observer.size(), 1u);
@@ -296,28 +296,28 @@ TEST(Observer, MultipleFilters) {
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<int>(entity);
registry.assign<char>(entity);
registry.emplace_or_replace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<int>(entity);
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
observer.clear();
registry.assign<double>(entity);
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<double>(entity);
registry.assign<float>(entity);
registry.emplace_or_replace<double>(entity);
registry.emplace<float>(entity);
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<double>(entity);
registry.emplace_or_replace<double>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
@@ -327,7 +327,7 @@ TEST(Observer, MultipleFilters) {
ASSERT_TRUE(observer.empty());
registry.assign_or_replace<int>(entity);
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
@@ -336,7 +336,7 @@ TEST(Observer, MultipleFilters) {
observer.clear();
observer.disconnect();
registry.assign_or_replace<int>(entity);
registry.emplace_or_replace<int>(entity);
ASSERT_TRUE(observer.empty());
}

298
test/entt/entity/registry.cpp
View File

@@ -121,8 +121,8 @@ TEST(Registry, Functionalities) {
const auto e0 = registry.create();
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
ASSERT_TRUE(registry.has<>(e0));
ASSERT_FALSE(registry.any<>(e1));
@@ -146,8 +146,8 @@ TEST(Registry, Functionalities) {
ASSERT_EQ(registry.try_get<double>(e0), nullptr);
ASSERT_EQ(registry.try_get<double>(e1), nullptr);
ASSERT_EQ(registry.assign<int>(e0, 42), 42);
ASSERT_EQ(registry.assign<char>(e0, 'c'), 'c');
ASSERT_EQ(registry.emplace<int>(e0, 42), 42);
ASSERT_EQ(registry.emplace<char>(e0, 'c'), 'c');
ASSERT_NO_THROW(registry.remove<int>(e1));
ASSERT_NO_THROW(registry.remove<char>(e1));
@@ -158,8 +158,8 @@ TEST(Registry, Functionalities) {
const auto e2 = registry.create();
registry.assign_or_replace<int>(e2, registry.get<int>(e0));
registry.assign_or_replace<char>(e2, registry.get<char>(e0));
registry.emplace_or_replace<int>(e2, registry.get<int>(e0));
registry.emplace_or_replace<char>(e2, registry.get<char>(e0));
ASSERT_TRUE((registry.has<int, char>(e2)));
ASSERT_EQ(registry.get<int>(e0), 42);
@@ -181,11 +181,11 @@ TEST(Registry, Functionalities) {
ASSERT_NE(&registry.get<int>(e0), &registry.get<int>(e2));
ASSERT_NE(&registry.get<char>(e0), &registry.get<char>(e2));
ASSERT_EQ(registry.replace<int>(e0, [](auto &instance) { instance = 2; }), 2);
ASSERT_EQ(registry.patch<int>(e0, [](auto &instance) { instance = 2; }), 2);
ASSERT_EQ(registry.replace<int>(e0, 3), 3);
ASSERT_NO_THROW(registry.assign_or_replace<int>(e0, 1));
ASSERT_NO_THROW(registry.assign_or_replace<int>(e1, 1));
ASSERT_NO_THROW(registry.emplace_or_replace<int>(e0, 1));
ASSERT_NO_THROW(registry.emplace_or_replace<int>(e1, 1));
ASSERT_EQ(static_cast<const entt::registry &>(registry).get<int>(e0), 1);
ASSERT_EQ(static_cast<const entt::registry &>(registry).get<int>(e1), 1);
@@ -215,8 +215,8 @@ TEST(Registry, Functionalities) {
const auto e3 = registry.create();
ASSERT_EQ(registry.get_or_assign<int>(e3, 3), 3);
ASSERT_EQ(registry.get_or_assign<char>(e3, 'c'), 'c');
ASSERT_EQ(registry.get_or_emplace<int>(e3, 3), 3);
ASSERT_EQ(registry.get_or_emplace<char>(e3, 'c'), 'c');
ASSERT_EQ(registry.size<int>(), entt::registry::size_type{1});
ASSERT_EQ(registry.size<char>(), entt::registry::size_type{1});
@@ -242,7 +242,7 @@ TEST(Registry, Functionalities) {
const auto e4 = registry.create();
const auto e5 = registry.create();
registry.assign<int>(e4);
registry.emplace<int>(e4);
ASSERT_NO_THROW(registry.remove_if_exists<int>(e4));
ASSERT_NO_THROW(registry.remove_if_exists<int>(e5));
@@ -264,16 +264,16 @@ TEST(Registry, ReplaceAggregate) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<aggregate>(entity, 0);
registry.emplace<aggregate>(entity, 0);
auto &instance = registry.replace<aggregate>(entity, 42);
ASSERT_EQ(instance.value, 42);
}
TEST(Registry, AssignOrReplaceAggregate) {
TEST(Registry, EmplaceOrReplaceAggregate) {
entt::registry registry;
const auto entity = registry.create();
auto &instance = registry.assign_or_replace<aggregate>(entity, 42);
auto &instance = registry.emplace_or_replace<aggregate>(entity, 42);
ASSERT_EQ(instance.value, 42);
}
@@ -306,7 +306,7 @@ TEST(Registry, RawData) {
ASSERT_EQ(std::as_const(registry).data<int>(), nullptr);
ASSERT_EQ(*std::as_const(registry).data(), entity);
registry.assign<int>(entity, 42);
registry.emplace<int>(entity, 42);
ASSERT_EQ(*registry.raw<int>(), 42);
ASSERT_EQ(*std::as_const(registry).raw<int>(), 42);
@@ -351,8 +351,8 @@ TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
registry.on_construct<int>().connect<&listener::incr<int>>(listener);
registry.create(std::begin(entities), std::end(entities));
registry.assign(std::begin(entities), std::end(entities), 42);
registry.assign(std::begin(entities), std::end(entities), 'c');
registry.insert(std::begin(entities), std::end(entities), 42);
registry.insert(std::begin(entities), std::end(entities), 'c');
ASSERT_EQ(registry.get<int>(entities[0]), 42);
ASSERT_EQ(registry.get<char>(entities[1]), 'c');
@@ -361,8 +361,8 @@ TEST(Registry, CreateManyEntitiesAtOnceWithListener) {
registry.on_construct<int>().disconnect<&listener::incr<int>>(listener);
registry.on_construct<empty_type>().connect<&listener::incr<empty_type>>(listener);
registry.create(std::begin(entities), std::end(entities));
registry.assign(std::begin(entities), std::end(entities), 'a');
registry.assign<empty_type>(std::begin(entities), std::end(entities));
registry.insert(std::begin(entities), std::end(entities), 'a');
registry.insert<empty_type>(std::begin(entities), std::end(entities));
ASSERT_TRUE(registry.has<empty_type>(entities[0]));
ASSERT_EQ(registry.get<char>(entities[2]), 'a');
@@ -422,14 +422,14 @@ TEST(Registry, CreateDestroyEntities) {
for(int i = 0; i < 10; ++i) {
const auto entity = registry.create();
registry.assign<double>(entity);
registry.emplace<double>(entity);
}
registry.clear();
for(int i = 0; i < 7; ++i) {
const auto entity = registry.create();
registry.assign<int>(entity);
registry.emplace<int>(entity);
if(i == 3) { pre = entity; }
}
@@ -478,9 +478,9 @@ TEST(Registry, Each) {
entt::registry::size_type match;
registry.create();
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
registry.create();
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
registry.create();
tot = 0u;
@@ -529,9 +529,9 @@ TEST(Registry, Orphans) {
entt::registry registry;
entt::registry::size_type tot{};
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
registry.create();
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
registry.orphans([&](auto) { ++tot; });
ASSERT_EQ(tot, 1u);
@@ -554,15 +554,15 @@ TEST(Registry, View) {
auto cview = registry.view<char>();
const auto e0 = registry.create();
registry.assign<int>(e0, 0);
registry.assign<char>(e0, 'c');
registry.emplace<int>(e0, 0);
registry.emplace<char>(e0, 'c');
const auto e1 = registry.create();
registry.assign<int>(e1, 0);
registry.emplace<int>(e1, 0);
const auto e2 = registry.create();
registry.assign<int>(e2, 0);
registry.assign<char>(e2, 'c');
registry.emplace<int>(e2, 0);
registry.emplace<char>(e2, 'c');
ASSERT_EQ(iview.size(), 3u);
ASSERT_EQ(cview.size(), 2u);
@@ -577,7 +577,7 @@ TEST(Registry, NonOwningGroupInitOnFirstUse) {
entt::registry registry;
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -592,12 +592,12 @@ TEST(Registry, NonOwningGroupInitOnFirstUse) {
ASSERT_EQ(cnt, 2u);
}
TEST(Registry, NonOwningGroupInitOnAssign) {
TEST(Registry, NonOwningGroupInitOnEmplace) {
entt::registry registry;
auto group = registry.group<>(entt::get<int, char>);
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -615,7 +615,7 @@ TEST(Registry, FullOwningGroupInitOnFirstUse) {
entt::registry registry;
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -632,12 +632,12 @@ TEST(Registry, FullOwningGroupInitOnFirstUse) {
ASSERT_EQ(cnt, 2u);
}
TEST(Registry, FullOwningGroupInitOnAssign) {
TEST(Registry, FullOwningGroupInitOnEmplace) {
entt::registry registry;
auto group = registry.group<int, char>();
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -657,7 +657,7 @@ TEST(Registry, PartialOwningGroupInitOnFirstUse) {
entt::registry registry;
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -675,12 +675,12 @@ TEST(Registry, PartialOwningGroupInitOnFirstUse) {
}
TEST(Registry, PartialOwningGroupInitOnAssign) {
TEST(Registry, PartialOwningGroupInitOnEmplace) {
entt::registry registry;
auto group = registry.group<int>(entt::get<char>);
auto create = [&](auto... component) {
const auto entity = registry.create();
(registry.assign<decltype(component)>(entity, component), ...);
(registry.emplace<decltype(component)>(entity, component), ...);
};
create(0, 'c');
@@ -701,8 +701,8 @@ TEST(Registry, CleanViewAfterRemoveAndClear) {
auto view = registry.view<int, char>();
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(view.size(), entt::registry::size_type{1});
@@ -710,7 +710,7 @@ TEST(Registry, CleanViewAfterRemoveAndClear) {
ASSERT_EQ(view.size(), entt::registry::size_type{0});
registry.assign<char>(entity, 'c');
registry.emplace<char>(entity, 'c');
ASSERT_EQ(view.size(), entt::registry::size_type{1});
@@ -718,7 +718,7 @@ TEST(Registry, CleanViewAfterRemoveAndClear) {
ASSERT_EQ(view.size(), entt::registry::size_type{0});
registry.assign<int>(entity, 0);
registry.emplace<int>(entity, 0);
ASSERT_EQ(view.size(), entt::registry::size_type{1});
@@ -732,8 +732,8 @@ TEST(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
auto group = registry.group<>(entt::get<int, char>);
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -741,7 +741,7 @@ TEST(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<char>(entity, 'c');
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -749,7 +749,7 @@ TEST(Registry, CleanNonOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<int>(entity, 0);
registry.emplace<int>(entity, 0);
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -763,8 +763,8 @@ TEST(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
auto group = registry.group<int, char>();
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -772,7 +772,7 @@ TEST(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<char>(entity, 'c');
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -780,7 +780,7 @@ TEST(Registry, CleanFullOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<int>(entity, 0);
registry.emplace<int>(entity, 0);
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -794,8 +794,8 @@ TEST(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
auto group = registry.group<int>(entt::get<char>);
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -803,7 +803,7 @@ TEST(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<char>(entity, 'c');
registry.emplace<char>(entity, 'c');
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -811,7 +811,7 @@ TEST(Registry, CleanPartialOwningGroupViewAfterRemoveAndClear) {
ASSERT_EQ(group.size(), entt::registry::size_type{0});
registry.assign<int>(entity, 0);
registry.emplace<int>(entity, 0);
ASSERT_EQ(group.size(), entt::registry::size_type{1});
@@ -825,8 +825,8 @@ TEST(Registry, NestedGroups) {
entt::entity entities[10];
registry.create(std::begin(entities), std::end(entities));
registry.assign<int>(std::begin(entities), std::end(entities));
registry.assign<char>(std::begin(entities), std::end(entities));
registry.insert<int>(std::begin(entities), std::end(entities));
registry.insert<char>(std::begin(entities), std::end(entities));
const auto g1 = registry.group<int>(entt::get<char>, entt::exclude<double>);
ASSERT_TRUE(g1.sortable());
@@ -844,7 +844,7 @@ TEST(Registry, NestedGroups) {
ASSERT_TRUE(g1.contains(entities[i*2]));
ASSERT_TRUE(g2.contains(entities[i*2+1]));
ASSERT_TRUE(g2.contains(entities[i*2]));
registry.assign<double>(entities[i*2]);
registry.emplace<double>(entities[i*2]);
}
ASSERT_EQ(g1.size(), 5u);
@@ -878,7 +878,7 @@ TEST(Registry, NestedGroups) {
ASSERT_TRUE(g2.contains(entities[i*2]));
ASSERT_FALSE(g3.contains(entities[i*2+1]));
ASSERT_FALSE(g3.contains(entities[i*2]));
registry.assign<int>(entities[i*2+1]);
registry.emplace<int>(entities[i*2+1]);
}
ASSERT_EQ(g1.size(), 5u);
@@ -892,7 +892,7 @@ TEST(Registry, NestedGroups) {
ASSERT_TRUE(g2.contains(entities[i*2]));
ASSERT_FALSE(g3.contains(entities[i*2+1]));
ASSERT_FALSE(g3.contains(entities[i*2]));
registry.assign<float>(entities[i*2]);
registry.emplace<float>(entities[i*2]);
}
ASSERT_EQ(g1.size(), 5u);
@@ -928,9 +928,9 @@ TEST(Registry, SortSingle) {
int val = 0;
registry.assign<int>(registry.create(), val++);
registry.assign<int>(registry.create(), val++);
registry.assign<int>(registry.create(), val++);
registry.emplace<int>(registry.create(), val++);
registry.emplace<int>(registry.create(), val++);
registry.emplace<int>(registry.create(), val++);
for(auto entity: registry.view<int>()) {
ASSERT_EQ(registry.get<int>(entity), --val);
@@ -951,8 +951,8 @@ TEST(Registry, SortMulti) {
for(auto i = 0; i < 3; ++i) {
const auto entity = registry.create();
registry.assign<unsigned int>(entity, uval++);
registry.assign<int>(entity, ival++);
registry.emplace<unsigned int>(entity, uval++);
registry.emplace<int>(entity, ival++);
}
for(auto entity: registry.view<unsigned int>()) {
@@ -978,9 +978,9 @@ TEST(Registry, SortMulti) {
TEST(Registry, SortEmpty) {
entt::registry registry;
registry.assign<empty_type>(registry.create());
registry.assign<empty_type>(registry.create());
registry.assign<empty_type>(registry.create());
registry.emplace<empty_type>(registry.create());
registry.emplace<empty_type>(registry.create());
registry.emplace<empty_type>(registry.create());
ASSERT_LT(registry.data<empty_type>()[0], registry.data<empty_type>()[1]);
ASSERT_LT(registry.data<empty_type>()[1], registry.data<empty_type>()[2]);
@@ -995,7 +995,7 @@ TEST(Registry, ComponentsWithTypesFromStandardTemplateLibrary) {
// see #37 - the test shouldn't crash, that's all
entt::registry registry;
const auto entity = registry.create();
registry.assign<std::unordered_set<int>>(entity).insert(42);
registry.emplace<std::unordered_set<int>>(entity).insert(42);
registry.destroy(entity);
}
@@ -1003,7 +1003,7 @@ TEST(Registry, ConstructWithComponents) {
// it should compile, that's all
entt::registry registry;
const auto value = 0;
registry.assign<int>(registry.create(), value);
registry.emplace<int>(registry.create(), value);
}
TEST(Registry, Signals) {
@@ -1018,14 +1018,14 @@ TEST(Registry, Signals) {
auto e0 = registry.create();
auto e1 = registry.create();
registry.assign<empty_type>(e0);
registry.assign<empty_type>(e1);
registry.emplace<empty_type>(e0);
registry.emplace<empty_type>(e1);
ASSERT_EQ(listener.counter, 2);
ASSERT_EQ(listener.last, e1);
registry.assign<int>(e1);
registry.assign<int>(e0);
registry.emplace<int>(e1);
registry.emplace<int>(e0);
ASSERT_EQ(listener.counter, 4);
ASSERT_EQ(listener.last, e0);
@@ -1048,8 +1048,8 @@ TEST(Registry, Signals) {
registry.on_construct<empty_type>().disconnect<&listener::incr<empty_type>>(listener);
registry.on_construct<int>().disconnect<&listener::incr<int>>(listener);
registry.assign<empty_type>(e1);
registry.assign<int>(e1);
registry.emplace<empty_type>(e1);
registry.emplace<int>(e1);
ASSERT_EQ(listener.counter, 2);
ASSERT_EQ(listener.last, e0);
@@ -1057,7 +1057,7 @@ TEST(Registry, Signals) {
registry.on_construct<int>().connect<&listener::incr<int>>(listener);
registry.on_destroy<int>().connect<&listener::decr<int>>(listener);
registry.assign<int>(e0);
registry.emplace<int>(e0);
registry.remove_if_exists<int>(e1);
ASSERT_EQ(listener.counter, 2);
@@ -1067,7 +1067,7 @@ TEST(Registry, Signals) {
registry.on_destroy<empty_type>().connect<&listener::decr<empty_type>>(listener);
registry.remove_if_exists<empty_type>(e1);
registry.assign<empty_type>(e0);
registry.emplace<empty_type>(e0);
ASSERT_EQ(listener.counter, 2);
ASSERT_EQ(listener.last, e0);
@@ -1078,10 +1078,10 @@ TEST(Registry, Signals) {
ASSERT_EQ(listener.counter, 0);
ASSERT_EQ(listener.last, e0);
registry.assign<empty_type>(e0);
registry.assign<empty_type>(e1);
registry.assign<int>(e0);
registry.assign<int>(e1);
registry.emplace<empty_type>(e0);
registry.emplace<empty_type>(e1);
registry.emplace<int>(e0);
registry.emplace<int>(e1);
registry.destroy(e1);
@@ -1090,8 +1090,8 @@ TEST(Registry, Signals) {
registry.remove<int>(e0);
registry.remove<empty_type>(e0);
registry.assign_or_replace<int>(e0);
registry.assign_or_replace<empty_type>(e0);
registry.emplace_or_replace<int>(e0);
registry.emplace_or_replace<empty_type>(e0);
ASSERT_EQ(listener.counter, 2);
ASSERT_EQ(listener.last, e0);
@@ -1099,17 +1099,17 @@ TEST(Registry, Signals) {
registry.on_destroy<empty_type>().disconnect<&listener::decr<empty_type>>(listener);
registry.on_destroy<int>().disconnect<&listener::decr<int>>(listener);
registry.assign_or_replace<empty_type>(e0);
registry.assign_or_replace<int>(e0);
registry.emplace_or_replace<empty_type>(e0);
registry.emplace_or_replace<int>(e0);
ASSERT_EQ(listener.counter, 2);
ASSERT_EQ(listener.last, e0);
registry.on_replace<empty_type>().connect<&listener::incr<empty_type>>(listener);
registry.on_replace<int>().connect<&listener::incr<int>>(listener);
registry.on_update<empty_type>().connect<&listener::incr<empty_type>>(listener);
registry.on_update<int>().connect<&listener::incr<int>>(listener);
registry.assign_or_replace<empty_type>(e0);
registry.assign_or_replace<int>(e0);
registry.emplace_or_replace<empty_type>(e0);
registry.emplace_or_replace<int>(e0);
ASSERT_EQ(listener.counter, 4);
ASSERT_EQ(listener.last, e0);
@@ -1128,14 +1128,14 @@ TEST(Registry, RangeDestroy) {
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.assign<double>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
registry.emplace<double>(e0);
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.assign<int>(e2);
registry.emplace<int>(e2);
ASSERT_TRUE(registry.valid(e0));
ASSERT_TRUE(registry.valid(e1));
@@ -1160,28 +1160,28 @@ TEST(Registry, RangeDestroy) {
ASSERT_FALSE(registry.valid(e2));
}
TEST(Registry, RangeAssign) {
TEST(Registry, RangeEmplace) {
entt::registry registry;
const auto e0 = registry.create();
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.assign<double>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
registry.emplace<double>(e0);
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.assign<int>(e2);
registry.emplace<int>(e2);
ASSERT_FALSE(registry.has<float>(e0));
ASSERT_FALSE(registry.has<float>(e1));
ASSERT_FALSE(registry.has<float>(e2));
const auto view = registry.view<int, char>();
registry.assign(view.begin(), view.end(), 3.f);
registry.insert(view.begin(), view.end(), 3.f);
ASSERT_EQ(registry.get<float>(e0), 3.f);
ASSERT_EQ(registry.get<float>(e1), 3.f);
@@ -1189,7 +1189,7 @@ TEST(Registry, RangeAssign) {
registry.clear<float>();
float value[3]{0.f, 1.f, 2.f};
registry.assign<float>(registry.data<int>(), registry.data<int>() + registry.size<int>(), value);
registry.insert<float>(registry.data<int>(), registry.data<int>() + registry.size<int>(), value, value + registry.size<int>());
ASSERT_EQ(registry.get<float>(e0), 0.f);
ASSERT_EQ(registry.get<float>(e1), 1.f);
@@ -1203,14 +1203,14 @@ TEST(Registry, RangeRemove) {
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.assign<double>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
registry.emplace<double>(e0);
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.assign<int>(e2);
registry.emplace<int>(e2);
ASSERT_TRUE(registry.has<int>(e0));
ASSERT_TRUE(registry.has<int>(e1));
@@ -1229,14 +1229,14 @@ TEST(Registry, NonOwningGroupInterleaved) {
typename entt::entity entity = entt::null;
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
const auto group = registry.group<>(entt::get<int, char>);
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
std::size_t cnt{};
group.each([&cnt](auto...) { ++cnt; });
@@ -1249,14 +1249,14 @@ TEST(Registry, FullOwningGroupInterleaved) {
typename entt::entity entity = entt::null;
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
const auto group = registry.group<int, char>();
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
std::size_t cnt{};
group.each([&cnt](auto...) { ++cnt; });
@@ -1269,14 +1269,14 @@ TEST(Registry, PartialOwningGroupInterleaved) {
typename entt::entity entity = entt::null;
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
const auto group = registry.group<int>(entt::get<char>);
entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
std::size_t cnt{};
group.each([&cnt](auto...) { ++cnt; });
@@ -1289,19 +1289,19 @@ TEST(Registry, NonOwningGroupSortInterleaved) {
const auto group = registry.group<>(entt::get<int, char>);
const auto e0 = registry.create();
registry.assign<int>(e0, 0);
registry.assign<char>(e0, '0');
registry.emplace<int>(e0, 0);
registry.emplace<char>(e0, '0');
const auto e1 = registry.create();
registry.assign<int>(e1, 1);
registry.assign<char>(e1, '1');
registry.emplace<int>(e1, 1);
registry.emplace<char>(e1, '1');
registry.sort<int>(std::greater{});
registry.sort<char>(std::less{});
const auto e2 = registry.create();
registry.assign<int>(e2, 2);
registry.assign<char>(e2, '2');
registry.emplace<int>(e2, 2);
registry.emplace<char>(e2, '2');
group.each([e0, e1, e2](const auto entity, const auto &i, const auto &c) {
if(entity == e0) {
@@ -1317,10 +1317,10 @@ TEST(Registry, NonOwningGroupSortInterleaved) {
});
}
TEST(Registry, GetOrAssign) {
TEST(Registry, GetOrEmplace) {
entt::registry registry;
const auto entity = registry.create();
const auto value = registry.get_or_assign<int>(entity, 3);
const auto value = registry.get_or_emplace<int>(entity, 3);
ASSERT_TRUE(registry.has<int>(entity));
ASSERT_EQ(registry.get<int>(entity), value);
ASSERT_EQ(registry.get<int>(entity), 3);
@@ -1329,8 +1329,8 @@ TEST(Registry, GetOrAssign) {
TEST(Registry, Constness) {
entt::registry registry;
ASSERT_TRUE((std::is_same_v<decltype(registry.assign<int>({})), int &>));
ASSERT_TRUE((std::is_same_v<decltype(registry.assign<empty_type>({})), void>));
ASSERT_TRUE((std::is_same_v<decltype(registry.emplace<int>({})), int &>));
ASSERT_TRUE((std::is_same_v<decltype(registry.emplace<empty_type>({})), void>));
ASSERT_TRUE((std::is_same_v<decltype(registry.get<int>({})), int &>));
ASSERT_TRUE((std::is_same_v<decltype(registry.get<int, char>({})), std::tuple<int &, char &>>));
@@ -1352,19 +1352,19 @@ TEST(Registry, BatchCreateAmbiguousCall) {
std::uint32_t foo = 32u;
std::uint64_t bar = 64u;
// this should work, no other tests required
registry.assign<ambiguous>(entity, foo, bar);
registry.emplace<ambiguous>(entity, foo, bar);
}
TEST(Registry, MoveOnlyComponent) {
entt::registry registry;
// the purpose is to ensure that move only types are always accepted
registry.assign<std::unique_ptr<int>>(registry.create());
registry.emplace<std::unique_ptr<int>>(registry.create());
}
TEST(Registry, NonDefaultConstructibleComponent) {
entt::registry registry;
// the purpose is to ensure that non default constructible type are always accepted
registry.assign<non_default_constructible>(registry.create(), 42);
registry.emplace<non_default_constructible>(registry.create(), 42);
}
TEST(Registry, Dependencies) {
@@ -1372,17 +1372,17 @@ TEST(Registry, Dependencies) {
const auto entity = registry.create();
// required because of an issue of VS2019
constexpr auto assign_or_replace = &entt::registry::assign_or_replace<double>;
constexpr auto emplace_or_replace = &entt::registry::emplace_or_replace<double>;
constexpr auto remove = &entt::registry::remove<double>;
registry.on_construct<int>().connect<assign_or_replace>();
registry.on_construct<int>().connect<emplace_or_replace>();
registry.on_destroy<int>().connect<remove>();
registry.assign<double>(entity, .3);
registry.emplace<double>(entity, .3);
ASSERT_FALSE(registry.has<int>(entity));
ASSERT_EQ(registry.get<double>(entity), .3);
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE(registry.has<int>(entity));
ASSERT_EQ(registry.get<double>(entity), .0);
@@ -1391,20 +1391,20 @@ TEST(Registry, Dependencies) {
ASSERT_FALSE((registry.any<int, double>(entity)));
registry.on_construct<int>().disconnect<assign_or_replace>();
registry.on_construct<int>().disconnect<emplace_or_replace>();
registry.on_destroy<int>().disconnect<remove>();
registry.assign<int>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE((registry.any<int, double>(entity)));
ASSERT_FALSE(registry.has<double>(entity));
}
TEST(Registry, StableAssign) {
TEST(Registry, StableEmplace) {
entt::registry registry;
registry.on_construct<int>().connect<&listener::sort<int>>();
registry.assign<int>(registry.create(), 0);
registry.emplace<int>(registry.create(), 0);
ASSERT_EQ(registry.assign<int>(registry.create(), 1), 1);
ASSERT_EQ(registry.emplace<int>(registry.create(), 1), 1);
}
TEST(Registry, AssignEntities) {
@@ -1430,9 +1430,9 @@ TEST(Registry, Visit) {
const auto entity = registry.create();
const auto other = registry.create();
registry.assign<int>(entity);
registry.assign<double>(other);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<double>(other);
registry.emplace<char>(entity);
bool hasType[3]{};

50
test/entt/entity/runtime_view.cpp
View File

@@ -18,14 +18,14 @@ TEST(RuntimeView, Functionalities) {
ASSERT_TRUE(view.empty());
const auto e0 = registry.create();
registry.assign<char>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
ASSERT_FALSE(view.empty());
registry.assign<char>(e1);
registry.emplace<char>(e1);
auto it = view.begin();
@@ -52,8 +52,8 @@ TEST(RuntimeView, Iterator) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ENTT_ID_TYPE types[] = { entt::type_info<int>::id(), entt::type_info<char>::id() };
auto view = registry.runtime_view(std::begin(types), std::end(types));
@@ -82,12 +82,12 @@ TEST(RuntimeView, Contains) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.destroy(e0);
@@ -102,13 +102,13 @@ TEST(RuntimeView, Empty) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<double>(e0);
registry.assign<int>(e0);
registry.assign<float>(e0);
registry.emplace<double>(e0);
registry.emplace<int>(e0);
registry.emplace<float>(e0);
const auto e1 = registry.create();
registry.assign<char>(e1);
registry.assign<float>(e1);
registry.emplace<char>(e1);
registry.emplace<float>(e1);
ENTT_ID_TYPE types[] = { entt::type_info<int>::id(), entt::type_info<char>::id(), entt::type_info<float>::id() };
auto view = registry.runtime_view(std::begin(types), std::end(types));
@@ -123,12 +123,12 @@ TEST(RuntimeView, Each) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
ENTT_ID_TYPE types[] = { entt::type_info<int>::id(), entt::type_info<char>::id() };
auto view = registry.runtime_view(std::begin(types), std::end(types));
@@ -146,11 +146,11 @@ TEST(RuntimeView, EachWithHoles) {
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<char>(e0, '0');
registry.assign<char>(e1, '1');
registry.emplace<char>(e0, '0');
registry.emplace<char>(e1, '1');
registry.assign<int>(e0, 0);
registry.assign<int>(e2, 2);
registry.emplace<int>(e0, 0);
registry.emplace<int>(e2, 2);
ENTT_ID_TYPE types[] = { entt::type_info<int>::id(), entt::type_info<char>::id() };
auto view = registry.runtime_view(std::begin(types), std::end(types));
@@ -164,7 +164,7 @@ TEST(RuntimeView, MissingPool) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
ENTT_ID_TYPE types[] = { entt::type_info<int>::id(), entt::type_info<char>::id() };
auto view = registry.runtime_view(std::begin(types), std::end(types));
@@ -172,7 +172,7 @@ TEST(RuntimeView, MissingPool) {
ASSERT_TRUE(view.empty());
ASSERT_EQ(view.size(), decltype(view.size()){0});
registry.assign<char>(e0);
registry.emplace<char>(e0);
ASSERT_TRUE(view.empty());
ASSERT_EQ(view.size(), decltype(view.size()){0});
@@ -187,7 +187,7 @@ TEST(RuntimeView, EmptyRange) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
const ENTT_ID_TYPE *ptr = nullptr;
auto view = registry.runtime_view(ptr, ptr);

44
test/entt/entity/snapshot.cpp
View File

@@ -68,18 +68,18 @@ TEST(Snapshot, Dump) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0, 42);
registry.assign<char>(e0, 'c');
registry.assign<double>(e0, .1);
registry.emplace<int>(e0, 42);
registry.emplace<char>(e0, 'c');
registry.emplace<double>(e0, .1);
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<int>(e2, 3);
registry.emplace<int>(e2, 3);
const auto e3 = registry.create();
registry.assign<a_component>(e3);
registry.assign<char>(e3, '0');
registry.emplace<a_component>(e3);
registry.emplace<char>(e3, '0');
registry.destroy(e1);
auto v1 = registry.current(e1);
@@ -134,17 +134,17 @@ TEST(Snapshot, Partial) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0, 42);
registry.assign<char>(e0, 'c');
registry.assign<double>(e0, .1);
registry.emplace<int>(e0, 42);
registry.emplace<char>(e0, 'c');
registry.emplace<double>(e0, .1);
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<int>(e2, 3);
registry.emplace<int>(e2, 3);
const auto e3 = registry.create();
registry.assign<char>(e3, '0');
registry.emplace<char>(e3, '0');
registry.destroy(e1);
auto v1 = registry.current(e1);
@@ -206,10 +206,10 @@ TEST(Snapshot, Iterator) {
for(auto i = 0; i < 50; ++i) {
const auto entity = registry.create();
registry.assign<another_component>(entity, i, i);
registry.emplace<another_component>(entity, i, i);
if(i % 2) {
registry.assign<a_component>(entity);
registry.emplace<a_component>(entity);
}
}
@@ -271,13 +271,13 @@ TEST(Snapshot, Continuous) {
entity = src.create();
entities.push_back(entity);
src.assign<a_component>(entity);
src.assign<another_component>(entity, i, i);
src.emplace<a_component>(entity);
src.emplace<another_component>(entity, i, i);
if(i % 2) {
src.assign<what_a_component>(entity, entity);
src.emplace<what_a_component>(entity, entity);
} else {
src.assign<map_component>(entity);
src.emplace<map_component>(entity);
}
}
@@ -294,8 +294,8 @@ TEST(Snapshot, Continuous) {
});
entity = dst.create();
dst.assign<a_component>(entity);
dst.assign<another_component>(entity, -1, -1);
dst.emplace<a_component>(entity);
dst.emplace<another_component>(entity, -1, -1);
entt::snapshot{src}.entities(output).component<a_component, another_component, what_a_component, map_component>(output);
@@ -525,10 +525,10 @@ TEST(Snapshot, SyncDataMembers) {
auto child = src.create();
src.assign<what_a_component>(parent, entt::null);
src.assign<what_a_component>(child, parent).quux.push_back(child);
src.emplace<what_a_component>(parent, entt::null);
src.emplace<what_a_component>(child, parent).quux.push_back(child);
src.assign<map_component>(
src.emplace<map_component>(
child,
decltype(map_component::keys){{{ child, 10 }}},
decltype(map_component::values){{{ 10, child }}},

154
test/entt/entity/view.cpp
View File

@@ -15,8 +15,8 @@ TEST(SingleComponentView, Functionalities) {
ASSERT_TRUE(view.empty());
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
ASSERT_NO_THROW(registry.view<char>().begin()++);
ASSERT_NO_THROW(++registry.view<char>().begin());
@@ -26,7 +26,7 @@ TEST(SingleComponentView, Functionalities) {
ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
ASSERT_FALSE(view.empty());
registry.assign<char>(e0);
registry.emplace<char>(e0);
ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
@@ -56,10 +56,10 @@ TEST(SingleComponentView, ElementAccess) {
auto cview = std::as_const(registry).view<const int>();
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
for(typename decltype(view)::size_type i{}; i < view.size(); ++i) {
ASSERT_EQ(view[i], i ? e0 : e1);
@@ -71,10 +71,10 @@ TEST(SingleComponentView, Contains) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
registry.destroy(e0);
@@ -88,11 +88,11 @@ TEST(SingleComponentView, Empty) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<char>(e0);
registry.assign<double>(e0);
registry.emplace<char>(e0);
registry.emplace<double>(e0);
const auto e1 = registry.create();
registry.assign<char>(e1);
registry.emplace<char>(e1);
auto view = registry.view<int>();
@@ -103,8 +103,8 @@ TEST(SingleComponentView, Empty) {
TEST(SingleComponentView, Each) {
entt::registry registry;
registry.assign<int>(registry.create());
registry.assign<int>(registry.create());
registry.emplace<int>(registry.create());
registry.emplace<int>(registry.create());
auto view = registry.view<int>();
std::size_t cnt = 0;
@@ -128,7 +128,7 @@ TEST(SingleComponentView, ConstNonConstAndAllInBetween) {
ASSERT_EQ(view.size(), decltype(view.size()){0});
ASSERT_EQ(cview.size(), decltype(cview.size()){0});
registry.assign<int>(registry.create(), 0);
registry.emplace<int>(registry.create(), 0);
ASSERT_EQ(view.size(), decltype(view.size()){1});
ASSERT_EQ(cview.size(), decltype(cview.size()){1});
@@ -155,16 +155,16 @@ TEST(SingleComponentView, Find) {
auto view = registry.view<int>();
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
const auto e2 = registry.create();
registry.assign<int>(e2);
registry.emplace<int>(e2);
const auto e3 = registry.create();
registry.assign<int>(e3);
registry.emplace<int>(e3);
registry.remove<int>(e1);
@@ -184,7 +184,7 @@ TEST(SingleComponentView, Find) {
const auto e4 = registry.create();
registry.destroy(e4);
const auto e5 = registry.create();
registry.assign<int>(e5);
registry.emplace<int>(e5);
ASSERT_NE(view.find(e5), view.end());
ASSERT_EQ(view.find(e4), view.end());
@@ -194,7 +194,7 @@ TEST(SingleComponentView, Less) {
entt::registry registry;
auto create = [&](auto... component) {
const auto entt = registry.create();
(registry.assign<decltype(component)>(entt, component), ...);
(registry.emplace<decltype(component)>(entt, component), ...);
return entt;
};
@@ -228,10 +228,10 @@ TEST(SingleComponentView, FrontBack) {
ASSERT_EQ(view.back(), static_cast<entt::entity>(entt::null));
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.emplace<int>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
ASSERT_EQ(view.front(), e1);
ASSERT_EQ(view.back(), e0);
@@ -247,16 +247,16 @@ TEST(MultiComponentView, Functionalities) {
ASSERT_TRUE((cview.empty<const int, const char>()));
const auto e0 = registry.create();
registry.assign<char>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.emplace<int>(e1);
ASSERT_FALSE(view.empty());
ASSERT_FALSE((view.empty<int>()));
ASSERT_FALSE((cview.empty<const char>()));
registry.assign<char>(e1);
registry.emplace<char>(e1);
auto it = registry.view<int, char>().begin();
@@ -294,8 +294,8 @@ TEST(MultiComponentView, Functionalities) {
TEST(MultiComponentView, Iterator) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
const auto view = registry.view<int, char>();
using iterator = typename decltype(view)::iterator;
@@ -323,12 +323,12 @@ TEST(MultiComponentView, Contains) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
registry.destroy(e0);
@@ -342,13 +342,13 @@ TEST(MultiComponentView, Empty) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<double>(e0);
registry.assign<int>(e0);
registry.assign<float>(e0);
registry.emplace<double>(e0);
registry.emplace<int>(e0);
registry.emplace<float>(e0);
const auto e1 = registry.create();
registry.assign<char>(e1);
registry.assign<float>(e1);
registry.emplace<char>(e1);
registry.emplace<float>(e1);
auto view = registry.view<char, int, float>();
@@ -360,12 +360,12 @@ TEST(MultiComponentView, Each) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
auto view = registry.view<int, char>();
auto cview = std::as_const(registry).view<const int, const char>();
@@ -387,13 +387,13 @@ TEST(MultiComponentView, EachWithType) {
for(auto i = 0; i < 3; ++i) {
const auto entity = registry.create();
registry.assign<int>(entity, i);
registry.assign<char>(entity);
registry.emplace<int>(entity, i);
registry.emplace<char>(entity);
}
// makes char a better candidate during iterations
const auto entity = registry.create();
registry.assign<int>(entity, 99);
registry.emplace<int>(entity, 99);
registry.view<int, char>().each<int>([value = 2](const auto curr, const auto) mutable {
ASSERT_EQ(curr, value--);
@@ -415,11 +415,11 @@ TEST(MultiComponentView, EachWithHoles) {
const auto e1 = registry.create();
const auto e2 = registry.create();
registry.assign<char>(e0, '0');
registry.assign<char>(e1, '1');
registry.emplace<char>(e0, '0');
registry.emplace<char>(e1, '1');
registry.assign<int>(e0, 0);
registry.assign<int>(e2, 2);
registry.emplace<int>(e0, 0);
registry.emplace<int>(e2, 2);
auto view = registry.view<char, int>();
@@ -437,8 +437,8 @@ TEST(MultiComponentView, ConstNonConstAndAllInBetween) {
ASSERT_EQ(view.size(), decltype(view.size()){0});
const auto entity = registry.create();
registry.assign<int>(entity, 0);
registry.assign<char>(entity, 'c');
registry.emplace<int>(entity, 0);
registry.emplace<char>(entity, 'c');
ASSERT_EQ(view.size(), decltype(view.size()){1});
@@ -459,20 +459,20 @@ TEST(MultiComponentView, Find) {
auto view = registry.view<int, const char>();
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto e2 = registry.create();
registry.assign<int>(e2);
registry.assign<char>(e2);
registry.emplace<int>(e2);
registry.emplace<char>(e2);
const auto e3 = registry.create();
registry.assign<int>(e3);
registry.assign<char>(e3);
registry.emplace<int>(e3);
registry.emplace<char>(e3);
registry.remove<int>(e1);
@@ -492,8 +492,8 @@ TEST(MultiComponentView, Find) {
const auto e4 = registry.create();
registry.destroy(e4);
const auto e5 = registry.create();
registry.assign<int>(e5);
registry.assign<char>(e5);
registry.emplace<int>(e5);
registry.emplace<char>(e5);
ASSERT_NE(view.find(e5), view.end());
ASSERT_EQ(view.find(e4), view.end());
@@ -503,20 +503,20 @@ TEST(MultiComponentView, ExcludedComponents) {
entt::registry registry;
const auto e0 = registry.create();
registry.assign<int>(e0, 0);
registry.emplace<int>(e0, 0);
const auto e1 = registry.create();
registry.assign<int>(e1, 1);
registry.assign<char>(e1);
registry.emplace<int>(e1, 1);
registry.emplace<char>(e1);
const auto view = registry.view<int>(entt::exclude<char>);
const auto e2 = registry.create();
registry.assign<int>(e2, 2);
registry.emplace<int>(e2, 2);
const auto e3 = registry.create();
registry.assign<int>(e3, 3);
registry.assign<char>(e3);
registry.emplace<int>(e3, 3);
registry.emplace<char>(e3);
for(const auto entity: view) {
ASSERT_TRUE(entity == e0 || entity == e2);
@@ -528,8 +528,8 @@ TEST(MultiComponentView, ExcludedComponents) {
}
}
registry.assign<char>(e0);
registry.assign<char>(e2);
registry.emplace<char>(e0);
registry.emplace<char>(e2);
registry.remove<char>(e1);
registry.remove<char>(e3);
@@ -548,14 +548,14 @@ TEST(MultiComponentView, Less) {
entt::registry registry;
const auto entity = registry.create();
registry.assign<int>(entity);
registry.assign<char>(entity);
registry.assign<double>(entity);
registry.assign<entt::tag<"empty"_hs>>(entity);
registry.emplace<int>(entity);
registry.emplace<char>(entity);
registry.emplace<double>(entity);
registry.emplace<entt::tag<"empty"_hs>>(entity);
const auto other = registry.create();
registry.assign<int>(other);
registry.assign<char>(other);
registry.emplace<int>(other);
registry.emplace<char>(other);
registry.view<int, char, entt::tag<"empty"_hs>>().less([entity](const auto entt, int, char) {
ASSERT_EQ(entity, entt);
@@ -592,15 +592,15 @@ TEST(MultiComponentView, FrontBack) {
ASSERT_EQ(view.back(), static_cast<entt::entity>(entt::null));
const auto e0 = registry.create();
registry.assign<int>(e0);
registry.assign<char>(e0);
registry.emplace<int>(e0);
registry.emplace<char>(e0);
const auto e1 = registry.create();
registry.assign<int>(e1);
registry.assign<char>(e1);
registry.emplace<int>(e1);
registry.emplace<char>(e1);
const auto entity = registry.create();
registry.assign<char>(entity);
registry.emplace<char>(entity);
ASSERT_EQ(view.front(), e1);
ASSERT_EQ(view.back(), e0);

4
test/lib/registry/lib.cpp
View File

@@ -9,11 +9,11 @@ ENTT_API void update_position(entt::registry &registry) {
});
}
ENTT_API void assign_velocity(entt::registry &registry) {
ENTT_API void emplace_velocity(entt::registry &registry) {
// forces the creation of the pool for the velocity component
registry.prepare<velocity>();
for(auto entity: registry.view<position>()) {
registry.assign<velocity>(entity, 1., 1.);
registry.emplace<velocity>(entity, 1., 1.);
}
}

6
test/lib/registry/main.cpp
View File

@@ -5,17 +5,17 @@
#include "types.h"
ENTT_API void update_position(entt::registry &);
ENTT_API void assign_velocity(entt::registry &);
ENTT_API void emplace_velocity(entt::registry &);
TEST(Lib, Registry) {
entt::registry registry;
for(auto i = 0; i < 3; ++i) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.emplace<position>(entity, i, i);
}
assign_velocity(registry);
emplace_velocity(registry);
update_position(registry);
ASSERT_EQ(registry.size<position>(), registry.size<velocity>());

4
test/lib/registry_plugin/main.cpp
View File

@@ -14,10 +14,10 @@ TEST(Lib, Registry) {
for(auto i = 0; i < 3; ++i) {
const auto entity = registry.create();
registry.assign<position>(entity, i, i);
registry.emplace<position>(entity, i, i);
if(i % 2) {
registry.assign<tag>(entity);
registry.emplace<tag>(entity);
}
}

2
test/lib/registry_plugin/plugin.cpp
View File

@@ -13,7 +13,7 @@ CR_EXPORT int cr_main(cr_plugin *ctx, cr_op operation) {
auto &registry = *static_cast<entt::registry *>(ctx->userdata);
const auto position_view = registry.view<position>(entt::exclude<tag>);
registry.assign(position_view.begin(), position_view.end(), velocity{1., 1.});
registry.insert(position_view.begin(), position_view.end(), velocity{1., 1.});
registry.view<position, velocity>().each([](auto &pos, auto &vel) {
pos.x += static_cast<int>(16 * vel.dx);

28
test/snapshot/snapshot.cpp
View File

@@ -42,19 +42,19 @@ TEST(Snapshot, Full) {
entt::registry destination;
auto e0 = source.create();
source.assign<position>(e0, 16.f, 16.f);
source.emplace<position>(e0, 16.f, 16.f);
source.destroy(source.create());
auto e1 = source.create();
source.assign<position>(e1, .8f, .0f);
source.assign<relationship>(e1, e0);
source.emplace<position>(e1, .8f, .0f);
source.emplace<relationship>(e1, e0);
auto e2 = source.create();
auto e3 = source.create();
source.assign<timer>(e3, 1000, 100);
source.assign<entt::tag<"empty"_hs>>(e3);
source.emplace<timer>(e3, 1000, 100);
source.emplace<entt::tag<"empty"_hs>>(e3);
source.destroy(e2);
auto v2 = source.current(e2);
@@ -106,21 +106,21 @@ TEST(Snapshot, Continuous) {
}
auto e0 = source.create();
source.assign<position>(e0, 0.f, 0.f);
source.assign<relationship>(e0, e0);
source.emplace<position>(e0, 0.f, 0.f);
source.emplace<relationship>(e0, e0);
auto e1 = source.create();
source.assign<position>(e1, 1.f, 1.f);
source.assign<relationship>(e1, e0);
source.emplace<position>(e1, 1.f, 1.f);
source.emplace<relationship>(e1, e0);
auto e2 = source.create();
source.assign<position>(e2, .2f, .2f);
source.assign<relationship>(e2, e0);
source.emplace<position>(e2, .2f, .2f);
source.emplace<relationship>(e2, e0);
auto e3 = source.create();
source.assign<timer>(e3, 1000, 1000);
source.assign<relationship>(e3, e2);
source.assign<entt::tag<"empty"_hs>>(e3);
source.emplace<timer>(e3, 1000, 1000);
source.emplace<relationship>(e3, e2);
source.emplace<entt::tag<"empty"_hs>>(e3);
{
// output finishes flushing its contents when it goes out of scope