registry: removed deprecated functions

src/entt/entity/registry.hpp

@@ -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.
      *

test/benchmark/benchmark.cpp

@@ -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;

test/entt/entity/actor.cpp

@@ -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};
 

test/entt/entity/entity.cpp

@@ -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);

test/entt/entity/group.cpp

@@ -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) {

test/entt/entity/helper.cpp

@@ -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);
 }

test/entt/entity/observer.cpp

@@ -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());
 }

test/entt/entity/registry.cpp

@@ -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]{};
 

test/entt/entity/runtime_view.cpp

@@ -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);

test/entt/entity/snapshot.cpp

@@ -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 }}},

test/entt/entity/view.cpp

@@ -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);

test/lib/registry/lib.cpp

@@ -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.);
     }
 }

test/lib/registry/main.cpp

@@ -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>());

test/lib/registry_plugin/main.cpp

@@ -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);
         }
     }
 

test/lib/registry_plugin/plugin.cpp

@@ -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);

test/snapshot/snapshot.cpp

@@ -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