test: basic continuous loader

test/entt/entity/snapshot.cpp

@@ -412,6 +412,7 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
     ASSERT_EQ(storage.get(entities[0u]), values[0u]);
     ASSERT_EQ(storage.get(entities[1u]), values[1u]);
 }
+
 TEST(BasicSnapshotLoader, Orphans) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
@@ -449,6 +450,371 @@ TEST(BasicSnapshotLoader, Orphans) {
     ASSERT_FALSE(registry.valid(entities[1u]));
 }
 
+TEST(BasicContinuousLoader, Constructors) {
+    static_assert(!std::is_default_constructible_v<entt::basic_continuous_loader<entt::registry>>);
+    static_assert(!std::is_copy_constructible_v<entt::basic_continuous_loader<entt::registry>>);
+    static_assert(!std::is_copy_assignable_v<entt::basic_continuous_loader<entt::registry>>);
+    static_assert(std::is_move_constructible_v<entt::basic_continuous_loader<entt::registry>>);
+    static_assert(std::is_move_assignable_v<entt::basic_continuous_loader<entt::registry>>);
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    entt::basic_continuous_loader other{std::move(loader)};
+
+    ASSERT_NO_FATAL_FAILURE(loader = std::move(other));
+}
+
+TEST(BasicContinuousLoader, GetEntityType) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    const auto &storage = registry.storage<entt::entity>();
+
+    std::vector<entt::any> data{};
+    auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
+    const entt::entity entities[3u]{traits_type::construct(1u, 0u), traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+
+    ASSERT_FALSE(registry.valid(entities[0u]));
+    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entities[2u]));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(0u));
+
+    loader.get<entt::entity>(archive);
+
+    ASSERT_FALSE(registry.valid(entities[0u]));
+    ASSERT_FALSE(registry.valid(entities[1u]));
+    ASSERT_FALSE(registry.valid(entities[2u]));
+
+    ASSERT_FALSE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entities[2u]));
+
+    ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+
+    ASSERT_EQ(storage.size(), 0u);
+    ASSERT_EQ(storage.in_use(), 0u);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(entities[1u]);
+    data.emplace_back(entities[2u]);
+
+    loader.get<entt::entity>(archive, "ignored"_hs);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entities[2u]));
+
+    ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 2u);
+    ASSERT_EQ(storage.in_use(), 2u);
+
+    ASSERT_EQ(storage[0u], loader.map(entities[0u]));
+    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
+
+    ASSERT_EQ(registry.create(), entities[2u]);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(entities[1u]);
+    data.emplace_back(entities[2u]);
+
+    loader.get<entt::entity>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_TRUE(loader.contains(entities[2u]));
+
+    ASSERT_NE(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[2u])));
+
+    ASSERT_EQ(storage.size(), 4u);
+    ASSERT_EQ(storage.in_use(), 4u);
+
+    ASSERT_EQ(storage[0u], loader.map(entities[0u]));
+    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
+    ASSERT_EQ(storage[3u], loader.map(entities[2u]));
+
+    registry.destroy(loader.map(entities[1u]));
+
+    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+
+    data.emplace_back(entities[1u]);
+
+    loader.get<entt::entity>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+    ASSERT_EQ(storage[3u], loader.map(entities[1u]));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+
+    data.emplace_back(entities[1u]);
+    data.emplace_back(entities[2u]);
+    data.emplace_back(entities[0u]);
+
+    loader.get<entt::entity>(archive, "ignored"_hs);
+
+    ASSERT_FALSE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+    ASSERT_FALSE(loader.contains(entities[2u]));
+
+    ASSERT_EQ(loader.map(entities[0u]), static_cast<entt::entity>(entt::null));
+    ASSERT_NE(loader.map(entities[1u]), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(loader.map(entities[2u]), static_cast<entt::entity>(entt::null));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 4u);
+    ASSERT_EQ(storage.in_use(), 2u);
+
+    ASSERT_EQ(storage[1u], loader.map(entities[1u]));
+}
+
+TEST(BasicContinuousLoader, GetType) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    const auto &storage = registry.storage<int>();
+
+    std::vector<entt::any> data{};
+    auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
+    const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const int values[2u]{1, 3};
+
+    ASSERT_FALSE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(entities[0u]);
+    data.emplace_back(values[0u]);
+
+    loader.get<int>(archive, "other"_hs);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 0u);
+    ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(values[0u]);
+
+    data.emplace_back(entities[1u]);
+    data.emplace_back(values[1u]);
+
+    loader.get<int>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 2u);
+    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
+    ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
+    ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
+}
+
+TEST(BasicContinuousLoader, GetEmptyType) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    const auto &storage = registry.storage<empty>();
+
+    std::vector<entt::any> data{};
+    auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
+    const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+
+    ASSERT_FALSE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(entities[0u]);
+
+    loader.get<empty>(archive, "other"_hs);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 0u);
+    ASSERT_EQ(registry.storage<empty>("other"_hs).size(), 1u);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(entities[1u]);
+
+    loader.get<empty>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 2u);
+    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
+}
+
+TEST(BasicContinuousLoader, GetTypeSparse) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    const auto &storage = registry.storage<int>();
+
+    std::vector<entt::any> data{};
+    auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
+    const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const int values[2u]{1, 3};
+
+    ASSERT_FALSE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_FALSE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<entt::entity>(entt::null));
+    data.emplace_back(entities[0u]);
+    data.emplace_back(values[0u]);
+
+    loader.get<int>(archive, "other"_hs);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_FALSE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 0u);
+    ASSERT_EQ(registry.storage<int>("other"_hs).size(), 1u);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(3u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(values[0u]);
+
+    data.emplace_back(static_cast<entt::entity>(entt::null));
+
+    data.emplace_back(entities[1u]);
+    data.emplace_back(values[1u]);
+
+    loader.get<int>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    ASSERT_EQ(storage.size(), 2u);
+    ASSERT_TRUE(storage.contains(loader.map(entities[0u])));
+    ASSERT_TRUE(storage.contains(loader.map(entities[1u])));
+    ASSERT_EQ(storage.get(loader.map(entities[0u])), values[0u]);
+    ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
+}
+
+TEST(BasicContinuousLoader, Shrink) {
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+
+    ASSERT_NO_FATAL_FAILURE(loader.shrink());
+}
+
+TEST(BasicContinuousLoader, Orphans) {
+    using namespace entt::literals;
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+
+    std::vector<entt::any> data{};
+    auto archive = [&data, pos = 0u](auto &value) mutable { value = entt::any_cast<std::remove_reference_t<decltype(value)>>(data[pos++]); };
+    const entt::entity entities[2u]{traits_type::construct(0u, 0u), traits_type::construct(2u, 0u)};
+    const int value = 42;
+
+    ASSERT_FALSE(registry.valid(entities[0u]));
+    ASSERT_FALSE(registry.valid(entities[1u]));
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+    data.emplace_back(static_cast<typename traits_type::entity_type>(2u));
+
+    data.emplace_back(entities[0u]);
+    data.emplace_back(entities[1u]);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(entities[0u]);
+    data.emplace_back(value);
+
+    loader.get<entt::entity>(archive);
+    loader.get<int>(archive);
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_TRUE(registry.valid(loader.map(entities[1u])));
+
+    loader.orphans();
+
+    ASSERT_TRUE(loader.contains(entities[0u]));
+    ASSERT_TRUE(loader.contains(entities[1u]));
+
+    ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
+    ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
+}
 
 template<typename Storage>
 struct output_archive {