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

observer: so long, and thanks for all the fish

Browse Source
This commit is contained in:
Michele Caini
2024-10-25 13:01:06 +02:00
parent e13c87a447
commit 15b9871205
8 changed files with 0 additions and 817 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/CMakeLists.txt
View File

@@ -229,7 +229,6 @@ SETUP_BASIC_TEST(entity entt/entity/entity.cpp)
SETUP_BASIC_TEST(group entt/entity/group.cpp)
SETUP_BASIC_TEST(handle entt/entity/handle.cpp)
SETUP_BASIC_TEST(helper entt/entity/helper.cpp)
SETUP_BASIC_TEST(observer entt/entity/observer.cpp)
SETUP_BASIC_TEST(organizer entt/entity/organizer.cpp)
SETUP_BASIC_TEST(reactive_mixin entt/entity/reactive_mixin.cpp)
SETUP_BASIC_TEST(registry entt/entity/registry.cpp)

1
test/entt/entity/BUILD.bazel
View File

@@ -8,7 +8,6 @@ _TESTS = [
"group",
"handle",
"helper",
"observer",
"organizer",
"reactive_mixin",
"registry",

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

@@ -1,368 +0,0 @@
#include <utility>
#include <gtest/gtest.h>
#include <entt/entity/observer.hpp>
#include <entt/entity/registry.hpp>
TEST(Observer, Functionalities) {
entt::registry registry;
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
entt::observer observer{registry, entt::collector.group<int>()};
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
ASSERT_EQ(observer.begin(), observer.end());
const auto entity = registry.create();
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
ASSERT_NE(observer.begin(), observer.end());
ASSERT_EQ(++observer.begin(), observer.end());
ASSERT_EQ(*observer.begin(), entity);
observer.clear();
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.erase<int>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, AllOf) {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
constexpr auto collector = entt::collector.group<int, char>(entt::exclude<float>).group<int, double>();
entt::registry registry;
entt::observer observer{registry, collector};
const auto entity = registry.create();
ASSERT_TRUE(observer.empty());
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.emplace<double>(entity);
ASSERT_FALSE(observer.empty());
registry.erase<int>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace<float>(entity);
registry.emplace<int>(entity);
ASSERT_FALSE(observer.empty());
registry.erase<double>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace<double>(entity);
observer.clear();
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
registry.erase<float>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, AllOfFiltered) {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
constexpr auto collector = entt::collector.group<int>().where<char>(entt::exclude<double>);
entt::registry registry;
entt::observer observer{registry, collector};
const auto entity = registry.create();
ASSERT_TRUE(observer.empty());
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
registry.erase<int>(entity);
registry.emplace<char>(entity);
registry.emplace<double>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE(observer.empty());
registry.erase<int>(entity);
registry.erase<double>(entity);
registry.emplace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
registry.erase<double>(entity);
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.erase<int>(entity);
registry.emplace<int>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, Observe) {
entt::registry registry;
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
entt::observer observer{registry, entt::collector.update<int>().update<char>()};
const auto entity = registry.create();
ASSERT_TRUE(observer.empty());
registry.emplace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
observer.clear();
registry.replace<char>(entity);
ASSERT_FALSE(observer.empty());
observer.clear();
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, ObserveFiltered) {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
constexpr auto collector = entt::collector.update<int>().where<char>(entt::exclude<double>);
entt::registry registry;
entt::observer observer{registry, collector};
const auto entity = registry.create();
ASSERT_TRUE(observer.empty());
registry.emplace<int>(entity);
registry.replace<int>(entity);
ASSERT_EQ(observer.size(), 0u);
ASSERT_TRUE(observer.empty());
registry.emplace<char>(entity);
registry.emplace<double>(entity);
registry.replace<int>(entity);
ASSERT_TRUE(observer.empty());
registry.erase<double>(entity);
registry.replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
registry.erase<double>(entity);
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.replace<int>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, AllOfObserve) {
entt::registry registry;
entt::observer observer{};
const auto entity = registry.create();
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
observer.connect(registry, entt::collector.group<int>().update<char>());
ASSERT_TRUE(observer.empty());
registry.emplace<int>(entity);
registry.emplace<char>(entity);
registry.replace<char>(entity);
registry.erase<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.erase<char>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
registry.replace<char>(entity);
observer.clear();
ASSERT_TRUE(observer.empty());
observer.disconnect();
registry.emplace_or_replace<int>(entity);
registry.emplace_or_replace<char>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, CrossRulesCornerCase) {
entt::registry registry;
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
entt::observer observer{registry, entt::collector.group<int>().group<char>()};
const auto entity = registry.create();
registry.emplace<int>(entity);
observer.clear();
ASSERT_TRUE(observer.empty());
registry.emplace<char>(entity);
registry.erase<int>(entity);
ASSERT_FALSE(observer.empty());
}
TEST(Observer, Each) {
entt::registry registry;
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
entt::observer observer{registry, entt::collector.group<int>()};
const auto entity = registry.create();
registry.emplace<int>(entity);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(observer.size(), 1u);
std::as_const(observer).each([entity](const auto entt) {
ASSERT_EQ(entity, entt);
});
ASSERT_FALSE(observer.empty());
ASSERT_EQ(observer.size(), 1u);
observer.each([entity](const auto entt) {
ASSERT_EQ(entity, entt);
});
ASSERT_TRUE(observer.empty());
ASSERT_EQ(observer.size(), 0u);
}
TEST(Observer, MultipleFilters) {
// NOLINTNEXTLINE(readability-static-accessed-through-instance)
constexpr auto collector = entt::collector.update<int>().where<char>().update<double>().where<float>();
entt::registry registry;
entt::observer observer{registry, collector};
const auto entity = registry.create();
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<int>(entity);
registry.emplace<char>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
observer.clear();
registry.emplace<double>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<double>(entity);
registry.emplace<float>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<double>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
registry.erase<float>(entity);
ASSERT_TRUE(observer.empty());
registry.emplace_or_replace<int>(entity);
ASSERT_EQ(observer.size(), 1u);
ASSERT_FALSE(observer.empty());
ASSERT_EQ(*observer.data(), entity);
observer.clear();
observer.disconnect();
registry.emplace_or_replace<int>(entity);
ASSERT_TRUE(observer.empty());
}
TEST(Observer, GroupCornerCase) {
// NOLINTBEGIN(readability-static-accessed-through-instance)
constexpr auto add_collector = entt::collector.group<int>(entt::exclude<char>);
constexpr auto remove_collector = entt::collector.group<int, char>();
// NOLINTEND(readability-static-accessed-through-instance)
entt::registry registry;
entt::observer add_observer{registry, add_collector};
entt::observer remove_observer{registry, remove_collector};
const auto entity = registry.create();
registry.emplace<int>(entity);
ASSERT_FALSE(add_observer.empty());
ASSERT_TRUE(remove_observer.empty());
add_observer.clear();
registry.emplace<char>(entity);
ASSERT_TRUE(add_observer.empty());
ASSERT_FALSE(remove_observer.empty());
remove_observer.clear();
registry.erase<char>(entity);
ASSERT_FALSE(add_observer.empty());
ASSERT_TRUE(remove_observer.empty());
}