update single include file to v3.12.2

src/entt/config/version.h

@@ -5,7 +5,7 @@
 
 #define ENTT_VERSION_MAJOR 3
 #define ENTT_VERSION_MINOR 12
-#define ENTT_VERSION_PATCH 0
+#define ENTT_VERSION_PATCH 2
 
 #define ENTT_VERSION \
     ENTT_XSTR(ENTT_VERSION_MAJOR) \

src/entt/entity/registry.hpp

@@ -527,7 +527,7 @@ public:
      * @return True if the identifier is valid, false otherwise.
      */
     [[nodiscard]] bool valid(const entity_type entt) const {
-        return entities.contains(entt);
+        return entities.contains(entt) && (entities.index(entt) < entities.in_use());
     }
 
     /**

src/entt/entity/snapshot.hpp

@@ -211,7 +211,9 @@ public:
     basic_snapshot_loader(registry_type &source) noexcept
         : reg{&source} {
         // restoring a snapshot as a whole requires a clean registry
-        ENTT_ASSERT(reg->empty(), "Registry must be empty");
+        for([[maybe_unused]] auto elem: source.storage()) {
+            ENTT_ASSERT(elem.second.empty(), "Registry must be empty");
+        }
     }
 
     /*! @brief Default move constructor. */
@@ -259,7 +261,9 @@ public:
                     if constexpr(Registry::template storage_for_type<Type>::traits_type::page_size == 0u) {
                         storage.emplace(entity);
                     } else {
-                        archive(storage.emplace(entity));
+                        Type elem{};
+                        archive(elem);
+                        storage.emplace(entity, std::move(elem));
                     }
                 }
             }
@@ -466,7 +470,9 @@ public:
                     if constexpr(Registry::template storage_for_type<Type>::traits_type::page_size == 0u) {
                         storage.emplace(map(entt));
                     } else {
-                        archive(storage.emplace(map(entt)));
+                        Type elem{};
+                        archive(elem);
+                        storage.emplace(map(entt), std::move(elem));
                     }
                 }
             }
@@ -523,9 +529,10 @@ public:
                     if constexpr(std::remove_reference_t<decltype(storage)>::traits_type::page_size == 0u) {
                         storage.emplace(map(entt));
                     } else {
-                        auto &elem = storage.emplace(map(entt));
+                        typename std::remove_reference_t<decltype(storage)>::value_type elem{};
                         archive(elem);
                         (update(elem, member), ...);
+                        storage.emplace(map(entt), std::move(elem));
                     }
                 }
             }

test/entt/entity/registry.cpp

@@ -576,8 +576,8 @@ TEST(Registry, CreateWithHint) {
     auto e2 = registry.create(entt::entity{3});
 
     ASSERT_EQ(e2, entt::entity{1});
-    ASSERT_TRUE(registry.valid(entt::entity{0}));
+    ASSERT_FALSE(registry.valid(entt::entity{0}));
-    ASSERT_TRUE(registry.valid(entt::entity{2}));
+    ASSERT_FALSE(registry.valid(entt::entity{2}));
     ASSERT_EQ(e3, entt::entity{3});
 
     registry.release(e2);

test/entt/entity/snapshot.cpp

@@ -11,11 +11,16 @@
 #include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/snapshot.hpp>
+#include <entt/signal/sigh.hpp>
 
 struct empty {};
 
 struct shadow {
     entt::entity target{entt::null};
+
+    static void listener(entt::entity &elem, entt::registry &registry, const entt::entity entt) {
+        elem = registry.get<shadow>(entt).target;
+    }
 };
 
 TEST(BasicSnapshot, Constructors) {
@@ -265,7 +270,7 @@ TEST(BasicSnapshotLoader, GetEntityType) {
 
     ASSERT_TRUE(registry.valid(entities[0u]));
     ASSERT_TRUE(registry.valid(entities[1u]));
-    ASSERT_TRUE(registry.valid(entities[2u]));
+    ASSERT_FALSE(registry.valid(entities[2u]));
 
     ASSERT_EQ(storage.size(), 3u);
     ASSERT_EQ(storage.in_use(), 2u);
@@ -417,6 +422,33 @@ TEST(BasicSnapshotLoader, GetTypeSparse) {
     ASSERT_EQ(storage.get(entities[1u]), values[1u]);
 }
 
+TEST(BasicSnapshotLoader, GetTypeWithListener) {
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_snapshot_loader loader{registry};
+    entt::entity check{entt::null};
+
+    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 auto entity{traits_type::construct(1u, 1u)};
+    const shadow value{entity};
+
+    ASSERT_FALSE(registry.valid(entity));
+    ASSERT_EQ(check, static_cast<entt::entity>(entt::null));
+
+    registry.on_construct<shadow>().connect<&shadow::listener>(check);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(entity);
+    data.emplace_back(value);
+
+    loader.get<shadow>(archive);
+
+    ASSERT_TRUE(registry.valid(entity));
+    ASSERT_EQ(check, entity);
+}
+
 TEST(BasicSnapshotLoader, Orphans) {
     using namespace entt::literals;
     using traits_type = entt::entt_traits<entt::entity>;
@@ -823,6 +855,33 @@ TEST(BasicContinuousLoader, GetTypeSparse) {
     ASSERT_EQ(storage.get(loader.map(entities[1u])), values[1u]);
 }
 
+TEST(BasicContinuousLoader, GetTypeWithListener) {
+    using traits_type = entt::entt_traits<entt::entity>;
+
+    entt::registry registry;
+    entt::basic_continuous_loader loader{registry};
+    entt::entity check{entt::null};
+
+    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 auto entity{traits_type::construct(1u, 1u)};
+    const shadow value{entity};
+
+    ASSERT_FALSE(registry.valid(loader.map(entity)));
+    ASSERT_EQ(check, static_cast<entt::entity>(entt::null));
+
+    registry.on_construct<shadow>().connect<&shadow::listener>(check);
+
+    data.emplace_back(static_cast<typename traits_type::entity_type>(1u));
+    data.emplace_back(entity);
+    data.emplace_back(value);
+
+    loader.get<shadow>(archive);
+
+    ASSERT_TRUE(registry.valid(loader.map(entity)));
+    ASSERT_EQ(check, entity);
+}
+
 TEST(BasicContinuousLoader, Shrink) {
     entt::registry registry;
     entt::basic_continuous_loader loader{registry};