snapshot: drop deprecated methods (and fix tests accordingly)

src/entt/entity/snapshot.hpp

@@ -140,45 +140,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Serializes all identifiers, including those to be recycled.
-     * @tparam Archive Type of output archive.
-     * @param archive A valid reference to an output archive.
-     * @return An object of this type to continue creating the snapshot.
-     */
-    template<typename Archive>
-    [[deprecated("use .get<Entity>(archive) instead")]] const basic_snapshot &entities(Archive &archive) const {
-        return get<entity_type>(archive);
-    }
-
-    /**
-     * @brief Serializes all elements of a type with associated identifiers.
-     * @tparam Component Types of components to serialize.
-     * @tparam Archive Type of output archive.
-     * @param archive A valid reference to an output archive.
-     * @return An object of this type to continue creating the snapshot.
-     */
-    template<typename... Component, typename Archive>
-    [[deprecated("use .get<Type>(archive) instead")]] const basic_snapshot &component(Archive &archive) const {
-        return (get<Component>(archive), ...);
-    }
-
-    /**
-     * @brief Serializes all elements of a type with associated identifiers for
-     * the entities in a range.
-     * @tparam Component Types of components to serialize.
-     * @tparam Archive Type of output archive.
-     * @tparam It Type of input iterator.
-     * @param archive A valid reference to an output archive.
-     * @param first An iterator to the first element of the range to serialize.
-     * @param last An iterator past the last element of the range to serialize.
-     * @return An object of this type to continue creating the snapshot.
-     */
-    template<typename... Component, typename Archive, typename It>
-    [[deprecated("use .get<Type>(archive, first, last) instead")]] const basic_snapshot &component(Archive &archive, It first, It last) const {
-        return (get<Component>(archive, first, last), ...);
-    }
-
 private:
     const registry_type *reg;
 };
@@ -229,7 +190,7 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename Type, typename Archive>
-    basic_snapshot_loader &get([[maybe_unused]] Archive &archive, const id_type id = type_hash<Type>::value()) {
+    basic_snapshot_loader &get(Archive &archive, const id_type id = type_hash<Type>::value()) {
         auto &storage = reg->template storage<Type>(id);
         typename traits_type::entity_type length{};
 
@@ -268,33 +229,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Restores all identifiers, including those to be recycled.
-     * @tparam Archive Type of input archive.
-     * @param archive A valid reference to an input archive.
-     * @return A valid loader to continue restoring data.
-     */
-    template<typename Archive>
-    [[deprecated("use .get<Entity>(archive) instead")]] basic_snapshot_loader &entities(Archive &archive) {
-        return get<entity_type>(archive);
-    }
-
-    /**
-     * @brief Restores all elements of a type with associated identifiers.
-     *
-     * The template parameter list must be exactly the same used during
-     * serialization.
-     *
-     * @tparam Component Type of component to restore.
-     * @tparam Archive Type of input archive.
-     * @param archive A valid reference to an input archive.
-     * @return A valid loader to continue restoring data.
-     */
-    template<typename... Component, typename Archive>
-    [[deprecated("use .get<Type>(archive) instead")]] basic_snapshot_loader &component(Archive &archive) {
-        return (get<Component>(archive), ...);
-    }
-
     /**
      * @brief Destroys those entities that have no components.
      *
@@ -425,7 +359,7 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename Type, typename Archive>
-    basic_continuous_loader &get([[maybe_unused]] Archive &archive, const id_type id = type_hash<Type>::value()) {
+    basic_continuous_loader &get(Archive &archive, const id_type id = type_hash<Type>::value()) {
         auto &storage = reg->template storage<Type>(id);
         typename traits_type::entity_type length{};
         entity_type entt{null};
@@ -475,78 +409,6 @@ public:
         return *this;
     }
 
-    /**
-     * @brief Restores all identifiers, including those to be recycled.
-     *
-     * It creates local counterparts for remote elements as needed.
-     *
-     * @tparam Archive Type of input archive.
-     * @param archive A valid reference to an input archive.
-     * @return A non-const reference to this loader.
-     */
-    template<typename Archive>
-    [[deprecated("use .get<Entity>(archive) instead")]] basic_continuous_loader &entities(Archive &archive) {
-        return get<entity_type>(archive);
-    }
-
-    /**
-     * @brief Serializes all elements of a type with associated identifiers.
-     *
-     * It creates local counterparts for remote elements as needed.<br/>
-     * Members are either data members of type entity_type or containers of
-     * entities. In both cases, a loader visits them and replaces entities with
-     * their local counterpart.
-     *
-     * @tparam Component Type of component to restore.
-     * @tparam Archive Type of input archive.
-     * @tparam Member Types of members to update with their local counterparts.
-     * @param archive A valid reference to an input archive.
-     * @param member Members to update with their local counterparts.
-     * @return A non-const reference to this loader.
-     */
-    template<typename... Component, typename Archive, typename... Member, typename... Clazz>
-    [[deprecated("use .component<Type>(archive, members...) instead")]] basic_continuous_loader &component(Archive &archive, Member Clazz::*...member) {
-        ([&](auto &storage) {
-            for(auto &&ref: remloc) {
-                storage.remove(ref.second.second);
-            }
-
-            typename traits_type::entity_type length{};
-            entity_type entt{null};
-
-            archive(length);
-
-            while(length--) {
-                if(archive(entt); entt != null) {
-                    restore(entt);
-
-                    if constexpr(std::remove_reference_t<decltype(storage)>::traits_type::page_size == 0u) {
-                        storage.emplace(map(entt));
-                    } else {
-                        auto &elem = storage.emplace(map(entt));
-                        archive(elem);
-                        (update(elem, member), ...);
-                    }
-                }
-            }
-        }(reg->template storage<Component>()),
-         ...);
-
-        return *this;
-    }
-
-    /**
-     * @brief Helps to purge entities that no longer have a counterpart.
-     *
-     * Users should invoke this member function after restoring each snapshot,
-     * unless they know exactly what they are doing.
-     *
-     * @return A non-const reference to this loader.
-     */
-    [[deprecated("use .get<Entity>(archive) instead")]] basic_continuous_loader &shrink() {
-        return *this;
-    }
-
     /**
      * @brief Destroys those entities that have no components.
      *

test/entt/entity/snapshot.cpp

@@ -823,13 +823,6 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
     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>;
@@ -872,595 +865,3 @@ TEST(BasicContinuousLoader, Orphans) {
     ASSERT_TRUE(registry.valid(loader.map(entities[0u])));
     ASSERT_FALSE(registry.valid(loader.map(entities[1u])));
 }
-
-template<typename Storage>
-struct output_archive {
-    output_archive(Storage &instance)
-        : storage{instance} {}
-
-    template<typename Value>
-    void operator()(const Value &value) {
-        std::get<std::queue<Value>>(storage).push(value);
-    }
-
-    void operator()(const std::unique_ptr<int> &instance) {
-        (*this)(*instance);
-    }
-
-private:
-    Storage &storage;
-};
-
-template<typename Storage>
-struct input_archive {
-    input_archive(Storage &instance)
-        : storage{instance} {}
-
-    template<typename Value>
-    void operator()(Value &value) {
-        auto assign = [this](auto &val) {
-            auto &queue = std::get<std::queue<std::decay_t<decltype(val)>>>(storage);
-            val = queue.front();
-            queue.pop();
-        };
-
-        assign(value);
-    }
-
-    void operator()(std::unique_ptr<int> &instance) {
-        instance = std::make_unique<int>();
-        (*this)(*instance);
-    }
-
-private:
-    Storage &storage;
-};
-
-struct a_component {};
-
-struct another_component {
-    int key{};
-    int value{};
-};
-
-struct what_a_component {
-    entt::entity bar{};
-    std::vector<entt::entity> quux{};
-};
-
-struct map_component {
-    std::map<entt::entity, int> keys{};
-    std::map<int, entt::entity> values{};
-    std::map<entt::entity, entt::entity> both{};
-};
-
-TEST(Snapshot, Dump) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
-    entt::registry registry;
-
-    const auto e0 = registry.create();
-    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.emplace<int>(e2, 3);
-
-    const auto e3 = registry.create();
-    registry.emplace<a_component>(e3);
-    registry.emplace<char>(e3, '0');
-
-    registry.destroy(e1);
-    auto v1 = registry.current(e1);
-
-    using archive_type = std::tuple<
-        std::queue<typename traits_type::entity_type>,
-        std::queue<entt::entity>,
-        std::queue<int>,
-        std::queue<char>,
-        std::queue<double>,
-        std::queue<a_component>,
-        std::queue<another_component>>;
-
-    archive_type storage;
-    output_archive<archive_type> output{storage};
-    input_archive<archive_type> input{storage};
-
-    entt::snapshot{registry}
-        .entities(output)
-        .component<int>(output)
-        .component<char>(output)
-        .component<double>(output)
-        .component<a_component>(output)
-        .component<another_component>(output);
-
-    registry.clear();
-
-    ASSERT_FALSE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_FALSE(registry.valid(e2));
-    ASSERT_FALSE(registry.valid(e3));
-
-    entt::snapshot_loader{registry}
-        .entities(input)
-        .component<int>(input)
-        .component<char>(input)
-        .component<double>(input)
-        .component<a_component>(input)
-        .component<another_component>(input)
-        .orphans();
-
-    ASSERT_TRUE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_TRUE(registry.valid(e2));
-    ASSERT_TRUE(registry.valid(e3));
-
-    ASSERT_FALSE(registry.orphan(e0));
-    ASSERT_FALSE(registry.orphan(e2));
-    ASSERT_FALSE(registry.orphan(e3));
-
-    ASSERT_EQ(registry.get<int>(e0), 42);
-    ASSERT_EQ(registry.get<char>(e0), 'c');
-    ASSERT_EQ(registry.get<double>(e0), .1);
-    ASSERT_EQ(registry.current(e1), v1);
-    ASSERT_EQ(registry.get<int>(e2), 3);
-    ASSERT_EQ(registry.get<char>(e3), '0');
-    ASSERT_TRUE(registry.all_of<a_component>(e3));
-
-    ASSERT_TRUE(registry.storage<another_component>().empty());
-}
-
-TEST(Snapshot, Partial) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
-    entt::registry registry;
-
-    const auto e0 = registry.create();
-    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.emplace<int>(e2, 3);
-
-    const auto e3 = registry.create();
-    registry.emplace<char>(e3, '0');
-
-    registry.destroy(e1);
-    auto v1 = registry.current(e1);
-
-    using archive_type = std::tuple<
-        std::queue<typename traits_type::entity_type>,
-        std::queue<entt::entity>,
-        std::queue<int>,
-        std::queue<char>,
-        std::queue<double>>;
-
-    archive_type storage;
-    output_archive<archive_type> output{storage};
-    input_archive<archive_type> input{storage};
-
-    entt::snapshot{registry}
-        .entities(output)
-        .component<char>(output)
-        .component<int>(output);
-
-    registry.clear();
-
-    ASSERT_FALSE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_FALSE(registry.valid(e2));
-    ASSERT_FALSE(registry.valid(e3));
-
-    entt::snapshot_loader{registry}
-        .entities(input)
-        .component<char>(input)
-        .component<int>(input);
-
-    ASSERT_TRUE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_TRUE(registry.valid(e2));
-    ASSERT_TRUE(registry.valid(e3));
-
-    ASSERT_EQ(registry.get<int>(e0), 42);
-    ASSERT_EQ(registry.get<char>(e0), 'c');
-    ASSERT_FALSE(registry.all_of<double>(e0));
-    ASSERT_EQ(registry.current(e1), v1);
-    ASSERT_EQ(registry.get<int>(e2), 3);
-    ASSERT_EQ(registry.get<char>(e3), '0');
-
-    entt::snapshot{registry}
-        .entities(output);
-
-    registry.clear();
-
-    ASSERT_FALSE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_FALSE(registry.valid(e2));
-    ASSERT_FALSE(registry.valid(e3));
-
-    entt::snapshot_loader{registry}
-        .entities(input)
-        .orphans();
-
-    ASSERT_FALSE(registry.valid(e0));
-    ASSERT_FALSE(registry.valid(e1));
-    ASSERT_FALSE(registry.valid(e2));
-    ASSERT_FALSE(registry.valid(e3));
-}
-
-TEST(Snapshot, Iterator) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
-    entt::registry registry;
-
-    for(auto i = 0; i < 50; ++i) {
-        const auto entity = registry.create();
-        registry.emplace<a_component>(entity);
-
-        if(i % 2) {
-            registry.emplace<another_component>(entity, i, i);
-            registry.emplace<std::unique_ptr<int>>(entity, std::make_unique<int>(i));
-        }
-    }
-
-    using archive_type = std::tuple<
-        std::queue<typename traits_type::entity_type>,
-        std::queue<entt::entity>,
-        std::queue<another_component>,
-        std::queue<int>>;
-
-    archive_type storage;
-    output_archive<archive_type> output{storage};
-    input_archive<archive_type> input{storage};
-
-    const auto view = registry.view<a_component>();
-    const auto size = view.size();
-
-    entt::snapshot{registry}
-        .component<another_component>(output, view.begin(), view.end())
-        .component<std::unique_ptr<int>>(output, view.begin(), view.end());
-
-    registry.clear();
-
-    entt::snapshot_loader{registry}
-        .component<another_component>(input)
-        .component<std::unique_ptr<int>>(input);
-
-    ASSERT_EQ(registry.view<another_component>().size(), size / 2u);
-
-    registry.view<another_component>().each([](const auto entity, const auto &) {
-        ASSERT_NE(entt::to_integral(entity) % 2u, 0u);
-    });
-}
-
-TEST(Snapshot, Continuous) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
-    entt::registry src;
-    entt::registry dst;
-
-    entt::continuous_loader loader{dst};
-
-    std::vector<entt::entity> entities;
-    entt::entity entity;
-
-    using archive_type = std::tuple<
-        std::queue<typename traits_type::entity_type>,
-        std::queue<entt::entity>,
-        std::queue<another_component>,
-        std::queue<what_a_component>,
-        std::queue<map_component>,
-        std::queue<int>,
-        std::queue<double>>;
-
-    archive_type storage;
-    output_archive<archive_type> output{storage};
-    input_archive<archive_type> input{storage};
-
-    for(int i = 0; i < 10; ++i) {
-        static_cast<void>(src.create());
-    }
-
-    src.clear();
-
-    for(int i = 0; i < 5; ++i) {
-        entity = src.create();
-        entities.push_back(entity);
-
-        src.emplace<a_component>(entity);
-        src.emplace<another_component>(entity, i, i);
-        src.emplace<std::unique_ptr<int>>(entity, std::make_unique<int>(i));
-
-        if(i % 2) {
-            src.emplace<what_a_component>(entity, entity);
-        } else {
-            src.emplace<map_component>(entity);
-        }
-    }
-
-    src.view<what_a_component>().each([&entities](auto, auto &what_a_component) {
-        what_a_component.quux.insert(what_a_component.quux.begin(), entities.begin(), entities.end());
-    });
-
-    src.view<map_component>().each([&entities](auto, auto &map_component) {
-        for(std::size_t i = 0; i < entities.size(); ++i) {
-            map_component.keys.insert({entities[i], int(i)});
-            map_component.values.insert({int(i), entities[i]});
-            map_component.both.insert({entities[entities.size() - i - 1], entities[i]});
-        }
-    });
-
-    entity = dst.create();
-    dst.emplace<a_component>(entity);
-    dst.emplace<another_component>(entity, -1, -1);
-    dst.emplace<std::unique_ptr<int>>(entity, std::make_unique<int>(-1));
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<a_component>(output)
-        .component<another_component>(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output)
-        .component<std::unique_ptr<int>>(output);
-
-    loader
-        .entities(input)
-        .component<a_component>(input)
-        .component<another_component>(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .component<std::unique_ptr<int>>(input)
-        .orphans();
-
-    decltype(dst.size()) a_component_cnt{};
-    decltype(dst.size()) another_component_cnt{};
-    decltype(dst.size()) what_a_component_cnt{};
-    decltype(dst.size()) map_component_cnt{};
-    decltype(dst.size()) unique_ptr_cnt{};
-
-    dst.each([&dst, &a_component_cnt](auto entt) {
-        ASSERT_TRUE(dst.all_of<a_component>(entt));
-        ++a_component_cnt;
-    });
-
-    dst.view<another_component>().each([&another_component_cnt](auto, const auto &component) {
-        ASSERT_EQ(component.value, component.key < 0 ? -1 : component.key);
-        ++another_component_cnt;
-    });
-
-    dst.view<what_a_component>().each([&dst, &what_a_component_cnt](auto entt, const auto &component) {
-        ASSERT_EQ(entt, component.bar);
-
-        for(auto child: component.quux) {
-            ASSERT_TRUE(dst.valid(child));
-        }
-
-        ++what_a_component_cnt;
-    });
-
-    dst.view<map_component>().each([&dst, &map_component_cnt](const auto &component) {
-        for(auto child: component.keys) {
-            ASSERT_TRUE(dst.valid(child.first));
-        }
-
-        for(auto child: component.values) {
-            ASSERT_TRUE(dst.valid(child.second));
-        }
-
-        for(auto child: component.both) {
-            ASSERT_TRUE(dst.valid(child.first));
-            ASSERT_TRUE(dst.valid(child.second));
-        }
-
-        ++map_component_cnt;
-    });
-
-    dst.view<std::unique_ptr<int>>().each([&dst, &unique_ptr_cnt](auto, const auto &component) {
-        ++unique_ptr_cnt;
-        ASSERT_EQ(*component, static_cast<int>(dst.storage<std::unique_ptr<int>>().size() - unique_ptr_cnt - 1u));
-    });
-
-    src.view<another_component>().each([](auto, auto &component) {
-        component.value = 2 * component.key;
-    });
-
-    auto size = dst.size();
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<a_component>(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output)
-        .component<another_component>(output);
-
-    loader
-        .entities(input)
-        .component<a_component>(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .component<another_component>(input)
-        .orphans();
-
-    ASSERT_EQ(size, dst.size());
-
-    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
-    ASSERT_EQ(dst.storage<another_component>().size(), another_component_cnt);
-    ASSERT_EQ(dst.storage<what_a_component>().size(), what_a_component_cnt);
-    ASSERT_EQ(dst.storage<map_component>().size(), map_component_cnt);
-    ASSERT_EQ(dst.storage<std::unique_ptr<int>>().size(), unique_ptr_cnt);
-
-    dst.view<another_component>().each([](auto, auto &component) {
-        ASSERT_EQ(component.value, component.key < 0 ? -1 : (2 * component.key));
-    });
-
-    entity = src.create();
-
-    src.view<what_a_component>().each([entity](auto, auto &component) {
-        component.bar = entity;
-    });
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<a_component>(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output)
-        .component<another_component>(output);
-
-    loader
-        .entities(input)
-        .component<a_component>(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .component<another_component>(input)
-        .orphans();
-
-    dst.view<what_a_component>().each([&loader, entity](auto, auto &component) {
-        ASSERT_EQ(component.bar, loader.map(entity));
-    });
-
-    entities.clear();
-    for(auto entt: src.view<a_component>()) {
-        entities.push_back(entt);
-    }
-
-    src.destroy(entity);
-    loader.shrink();
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<a_component>(output)
-        .component<another_component>(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output);
-
-    loader
-        .entities(input)
-        .component<a_component>(input)
-        .component<another_component>(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .orphans()
-        .shrink();
-
-    dst.view<what_a_component>().each([&dst](auto, auto &component) {
-        ASSERT_FALSE(dst.valid(component.bar));
-    });
-
-    ASSERT_FALSE(loader.contains(entity));
-
-    entity = src.create();
-
-    src.view<what_a_component>().each([entity](auto, auto &component) {
-        component.bar = entity;
-    });
-
-    dst.clear<a_component>();
-    a_component_cnt = src.storage<a_component>().size();
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<a_component>(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output)
-        .component<another_component>(output);
-
-    loader
-        .entities(input)
-        .component<a_component>(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .component<another_component>(input)
-        .orphans();
-
-    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
-
-    src.clear<a_component>();
-    a_component_cnt = {};
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output)
-        .component<a_component>(output)
-        .component<another_component>(output);
-
-    loader
-        .entities(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both)
-        .component<a_component>(input)
-        .component<another_component>(input)
-        .orphans();
-
-    ASSERT_EQ(dst.storage<a_component>().size(), a_component_cnt);
-}
-
-TEST(Snapshot, SyncDataMembers) {
-    using traits_type = entt::entt_traits<entt::entity>;
-
-    entt::registry src;
-    entt::registry dst;
-
-    entt::continuous_loader loader{dst};
-
-    using archive_type = std::tuple<
-        std::queue<typename traits_type::entity_type>,
-        std::queue<entt::entity>,
-        std::queue<what_a_component>,
-        std::queue<map_component>>;
-
-    archive_type storage;
-    output_archive<archive_type> output{storage};
-    input_archive<archive_type> input{storage};
-
-    static_cast<void>(src.create());
-    static_cast<void>(src.create());
-
-    src.clear();
-
-    auto parent = src.create();
-    auto child = src.create();
-
-    src.emplace<what_a_component>(parent, entt::null);
-    src.emplace<what_a_component>(child, parent).quux.push_back(child);
-
-    src.emplace<map_component>(
-        child,
-        decltype(map_component::keys){{{child, 10}}},
-        decltype(map_component::values){{{10, child}}},
-        decltype(map_component::both){{{child, child}}});
-
-    entt::snapshot{src}
-        .entities(output)
-        .component<what_a_component>(output)
-        .component<map_component>(output);
-
-    loader
-        .entities(input)
-        .component<what_a_component>(input, &what_a_component::bar, &what_a_component::quux)
-        .component<map_component>(input, &map_component::keys, &map_component::values, &map_component::both);
-
-    ASSERT_FALSE(dst.valid(parent));
-    ASSERT_FALSE(dst.valid(child));
-
-    ASSERT_TRUE(dst.all_of<what_a_component>(loader.map(parent)));
-    ASSERT_TRUE(dst.all_of<what_a_component>(loader.map(child)));
-
-    ASSERT_EQ(dst.get<what_a_component>(loader.map(parent)).bar, static_cast<entt::entity>(entt::null));
-
-    const auto &component = dst.get<what_a_component>(loader.map(child));
-
-    ASSERT_EQ(component.bar, loader.map(parent));
-    ASSERT_EQ(component.quux[0], loader.map(child));
-
-    const auto &elem = dst.get<map_component>(loader.map(child));
-    ASSERT_EQ(elem.keys.at(loader.map(child)), 10);
-    ASSERT_EQ(elem.values.at(10), loader.map(child));
-    ASSERT_EQ(elem.both.at(loader.map(child)), loader.map(child));
-}

test/snapshot/snapshot.cpp

@@ -64,21 +64,23 @@ TEST(Snapshot, Full) {
     {
         // output finishes flushing its contents when it goes out of scope
         cereal::JSONOutputArchive output{storage};
+
         entt::snapshot{source}
-            .entities(output)
-            .component<position>(output)
-            .component<timer>(output)
-            .component<relationship>(output)
-            .component<entt::tag<"empty"_hs>>(output);
+            .get<entt::entity>(output)
+            .get<position>(output)
+            .get<timer>(output)
+            .get<relationship>(output)
+            .get<entt::tag<"empty"_hs>>(output);
     }
 
     cereal::JSONInputArchive input{storage};
+
     entt::snapshot_loader{destination}
-        .entities(input)
-        .component<position>(input)
-        .component<timer>(input)
-        .component<relationship>(input)
-        .component<entt::tag<"empty"_hs>>(input);
+        .get<entt::entity>(input)
+        .get<position>(input)
+        .get<timer>(input)
+        .get<relationship>(input)
+        .get<entt::tag<"empty"_hs>>(input);
 
     ASSERT_TRUE(destination.valid(e0));
     ASSERT_TRUE(destination.all_of<position>(e0));
@@ -139,22 +141,32 @@ TEST(Snapshot, Continuous) {
     {
         // output finishes flushing its contents when it goes out of scope
         cereal::JSONOutputArchive output{storage};
+
         entt::snapshot{source}
-            .component<entt::entity>(output)
-            .component<position>(output)
-            .component<relationship>(output)
-            .component<timer>(output)
-            .component<entt::tag<"empty"_hs>>(output);
+            .get<entt::entity>(output)
+            .get<position>(output)
+            .get<relationship>(output)
+            .get<timer>(output)
+            .get<entt::tag<"empty"_hs>>(output);
     }
 
     cereal::JSONInputArchive input{storage};
     entt::continuous_loader loader{destination};
+
+    auto archive = [&input, &loader](auto &value) {
+        input(value);
+
+        if constexpr(std::is_same_v<std::remove_reference_t<decltype(value)>, relationship>) {
+            value.parent = loader.map(value.parent);
+        }
+    };
+
     loader
-        .entities(input)
-        .component<position>(input)
-        .component<relationship>(input, &relationship::parent)
-        .component<timer>(input)
-        .component<entt::tag<"empty"_hs>>(input);
+        .get<entt::entity>(input)
+        .get<position>(input)
+        .get<relationship>(archive)
+        .get<timer>(input)
+        .get<entt::tag<"empty"_hs>>(input);
 
     ASSERT_FALSE(destination.valid(e0));
     ASSERT_TRUE(loader.contains(e0));