removed extra create functions from the registry (#52)

src/entt/entity/registry.hpp

@@ -339,61 +339,6 @@ public:
         return version_type((entities[pos] >> traits_type::entity_shift) & traits_type::version_mask);
     }
 
-    /**
-     * @brief Returns a new entity initialized with the given components.
-     *
-     * There are two kinds of entity identifiers:
-     *
-     * * Newly created ones in case no entities have been previously destroyed.
-     * * Recycled one with updated versions.
-     *
-     * Users should not care about the type of the returned entity identifier.
-     * In case entity identifers are stored around, the `current` member
-     * function can be used to know if they are still valid or the entity has
-     * been destroyed and potentially recycled.
-     *
-     * The returned entity has fully initialized components assigned.
-     *
-     * @tparam Component A list of components to assign to the entity.
-     * @param components Instances with which to initialize components.
-     * @return A valid entity identifier.
-     */
-    template<typename... Component>
-    entity_type create(Component &&... components) noexcept {
-        using accumulator_type = int[];
-        const auto entity = create();
-        accumulator_type accumulator = { 0, (assure<std::decay_t<Component>>().construct(entity, std::forward<Component>(components)), 0)... };
-        (void)accumulator;
-        return entity;
-    }
-
-    /**
-     * @brief Returns a new entity to which the given components are assigned.
-     *
-     * There are two kinds of entity identifiers:
-     *
-     * * Newly created ones in case no entities have been previously destroyed.
-     * * Recycled one with updated versions.
-     *
-     * Users should not care about the type of the returned entity identifier.
-     * In case entity identifers are stored around, the `current` member
-     * function can be used to know if they are still valid or the entity has
-     * been destroyed and potentially recycled.
-     *
-     * The returned entity has default initialized components assigned.
-     *
-     * @tparam Component A list of components to assign to the entity.
-     * @return A valid entity identifier.
-     */
-    template<typename... Component>
-    entity_type create() noexcept {
-        using accumulator_type = int[];
-        const auto entity = create();
-        accumulator_type accumulator = { 0, (assure<Component>().construct(entity), 0)... };
-        (void)accumulator;
-        return entity;
-    }
-
     /**
      * @brief Creates a new entity and returns it.
      *

test/benchmark/benchmark.cpp

@@ -73,17 +73,17 @@ TEST(Benchmark, IterateCreateDeleteSingleComponent) {
 
     for(int i = 0; i < 10000; i++) {
         for(int j = 0; j < 10000; j++) {
-            registry.create<Position>();
+            const auto entity = registry.create();
+            registry.assign<Position>(entity);
         }
 
-        for(auto entity: view) {
-            const auto &position = view.get(entity);
+        view.each([&](auto entity, auto &position) {
             (void)position;
 
             if(rand() % 2 == 0) {
                 registry.destroy(entity);
             }
-        };
+        });
     }
 
     timer.elapsed();
@@ -95,7 +95,8 @@ TEST(Benchmark, IterateSingleComponent1M) {
     std::cout << "Iterating over 1000000 entities, one component" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
     }
 
     Timer timer;
@@ -109,7 +110,8 @@ TEST(Benchmark, IterateSingleComponentRaw1M) {
     std::cout << "Iterating over 1000000 entities, one component, raw view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
     }
 
     Timer timer;
@@ -125,7 +127,9 @@ TEST(Benchmark, IterateTwoComponents1M) {
     std::cout << "Iterating over 1000000 entities, two components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
     }
 
     Timer timer;
@@ -139,8 +143,12 @@ TEST(Benchmark, IterateTwoComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, two components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i % 2) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -154,8 +162,12 @@ TEST(Benchmark, IterateTwoComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, two components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -170,7 +182,9 @@ TEST(Benchmark, IterateTwoComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, two components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
     }
 
     Timer timer;
@@ -184,7 +198,12 @@ TEST(Benchmark, IterateFiveComponents1M) {
     std::cout << "Iterating over 1000000 entities, five components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
     }
 
     Timer timer;
@@ -198,8 +217,15 @@ TEST(Benchmark, IterateFiveComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, five components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>>();
-        if(i % 2) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -213,8 +239,15 @@ TEST(Benchmark, IterateFiveComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, five components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -229,7 +262,12 @@ TEST(Benchmark, IterateFiveComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, five components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
     }
 
     Timer timer;
@@ -243,7 +281,17 @@ TEST(Benchmark, IterateTenComponents1M) {
     std::cout << "Iterating over 1000000 entities, ten components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
     }
 
     Timer timer;
@@ -257,8 +305,20 @@ TEST(Benchmark, IterateTenComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, ten components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-        if(i % 2) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -272,8 +332,20 @@ TEST(Benchmark, IterateTenComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, ten components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
     Timer timer;
@@ -288,7 +360,17 @@ TEST(Benchmark, IterateTenComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, ten components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
     }
 
     Timer timer;
@@ -302,7 +384,8 @@ TEST(Benchmark, SortSingle) {
     std::cout << "Sort 150000 entities, one component" << std::endl;
 
     for(std::uint64_t i = 0; i < 150000L; i++) {
-        registry.create<Position>({ i, i });
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
     }
 
     Timer timer;
@@ -320,7 +403,9 @@ TEST(Benchmark, SortMulti) {
     std::cout << "Sort 150000 entities, two components" << std::endl;
 
     for(std::uint64_t i = 0; i < 150000L; i++) {
-        registry.create<Position, Velocity>({ i, i }, { i, i });
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
+        registry.assign<Velocity>(entity, i, i);
     }
 
     registry.sort<Position>([](const auto &lhs, const auto &rhs) {

test/entt/entity/registry.cpp

@@ -36,8 +36,11 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_TRUE(registry.empty<int>());
     ASSERT_TRUE(registry.empty<char>());
 
-    auto e0 = registry.create();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     ASSERT_TRUE(registry.has<>(e0));
     ASSERT_TRUE(registry.has<>(e1));
@@ -69,7 +72,7 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_TRUE((registry.has<int, char>(e0)));
     ASSERT_FALSE((registry.has<int, char>(e1)));
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
 
     registry.accommodate<int>(e2, registry.get<int>(e0));
     registry.accommodate<char>(e2, registry.get<char>(e0));
@@ -121,7 +124,10 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{0});
     ASSERT_TRUE(registry.empty());
 
-    registry.create<int, char>();
+    const auto e3 = registry.create();
+
+    registry.assign<int>(e3);
+    registry.assign<char>(e3);
 
     ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{1});
     ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{1});
@@ -142,11 +148,13 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_TRUE(registry.empty<int>());
     ASSERT_TRUE(registry.empty<char>());
 
-    e0 = registry.create<int>();
-    e1 = registry.create();
+    const auto e4 = registry.create();
+    const auto e5 = registry.create();
 
-    ASSERT_NO_THROW(registry.reset<int>(e0));
-    ASSERT_NO_THROW(registry.reset<int>(e1));
+    registry.assign<int>(e4);
+
+    ASSERT_NO_THROW(registry.reset<int>(e4));
+    ASSERT_NO_THROW(registry.reset<int>(e5));
 
     ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{0});
     ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{0});
@@ -156,8 +164,8 @@ TEST(DefaultRegistry, Functionalities) {
 TEST(DefaultRegistry, CreateDestroyCornerCase) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
-    auto e1 = registry.create();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
 
     registry.destroy(e0);
     registry.destroy(e1);
@@ -171,7 +179,7 @@ TEST(DefaultRegistry, CreateDestroyCornerCase) {
 TEST(DefaultRegistry, VersionOverflow) {
     entt::DefaultRegistry registry;
 
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.destroy(entity);
 
     ASSERT_EQ(registry.version(entity), entt::DefaultRegistry::version_type{});
@@ -190,9 +198,9 @@ TEST(DefaultRegistry, Each) {
     entt::DefaultRegistry::size_type match;
 
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
 
     tot = 0u;
@@ -241,9 +249,9 @@ TEST(DefaultRegistry, Orphans) {
     entt::DefaultRegistry registry;
     entt::DefaultRegistry::size_type tot{};
 
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
     registry.attach<double>(registry.create());
 
@@ -276,20 +284,22 @@ TEST(DefaultRegistry, CreateDestroyEntities) {
     entt::DefaultRegistry::entity_type pre{}, post{};
 
     for(int i = 0; i < 10; ++i) {
-        registry.create<double>();
+        const auto entity = registry.create();
+        registry.assign<double>(entity);
     }
 
     registry.reset();
 
     for(int i = 0; i < 7; ++i) {
-        auto entity = registry.create<int>();
+        const auto entity = registry.create();
+        registry.assign<int>(entity);
         if(i == 3) { pre = entity; }
     }
 
     registry.reset();
 
     for(int i = 0; i < 5; ++i) {
-        auto entity = registry.create();
+        const auto entity = registry.create();
         if(i == 3) { post = entity; }
     }
 
@@ -306,7 +316,7 @@ TEST(DefaultRegistry, AttachSetRemoveTags) {
 
     ASSERT_FALSE(registry.has<int>());
 
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.attach<int>(entity, 42);
 
     ASSERT_TRUE(registry.has<int>());
@@ -321,7 +331,7 @@ TEST(DefaultRegistry, AttachSetRemoveTags) {
     ASSERT_EQ(cregistry.get<int>(), 3);
     ASSERT_EQ(registry.attachee<int>(), entity);
 
-    auto other = registry.create();
+    const auto other = registry.create();
     registry.move<int>(other);
 
     ASSERT_TRUE(registry.has<int>());
@@ -345,9 +355,16 @@ TEST(DefaultRegistry, StandardViews) {
     auto iview = registry.view<int>();
     auto cview = registry.view<char>();
 
-    registry.create(0, 'c');
-    registry.create(0);
-    registry.create(0, 'c');
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 0);
+    registry.assign<char>(e0, 'c');
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 0);
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 0);
+    registry.assign<char>(e2, 'c');
 
     ASSERT_EQ(iview.size(), decltype(iview)::size_type{3});
     ASSERT_EQ(cview.size(), decltype(cview)::size_type{2});
@@ -373,9 +390,16 @@ TEST(DefaultRegistry, PersistentViews) {
 
     ASSERT_FALSE((registry.contains<int, double>()));
 
-    registry.create(0, 'c');
-    registry.create(0);
-    registry.create(0, 'c');
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 0);
+    registry.assign<char>(e0, 'c');
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 0);
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 0);
+    registry.assign<char>(e2, 'c');
 
     decltype(view)::size_type cnt{0};
     view.each([&cnt](auto...) { ++cnt; });
@@ -386,7 +410,7 @@ TEST(DefaultRegistry, PersistentViews) {
 TEST(DefaultRegistry, CleanStandardViewsAfterReset) {
     entt::DefaultRegistry registry;
     auto view = registry.view<int>();
-    registry.create(0);
+    registry.assign<int>(registry.create(), 0);
 
     ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
 
@@ -398,7 +422,10 @@ TEST(DefaultRegistry, CleanStandardViewsAfterReset) {
 TEST(DefaultRegistry, CleanPersistentViewsAfterReset) {
     entt::DefaultRegistry registry;
     auto view = registry.persistent<int, char>();
-    registry.create(0, 'c');
+
+    const auto entity = registry.create();
+    registry.assign<int>(entity, 0);
+    registry.assign<char>(entity, 'c');
 
     ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
 
@@ -409,7 +436,7 @@ TEST(DefaultRegistry, CleanPersistentViewsAfterReset) {
 
 TEST(DefaultRegistry, CleanTagsAfterReset) {
     entt::DefaultRegistry registry;
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.attach<int>(entity);
 
     ASSERT_TRUE(registry.has<int>());
@@ -424,9 +451,9 @@ TEST(DefaultRegistry, SortSingle) {
 
     int val = 0;
 
-    registry.create(val++);
-    registry.create(val++);
-    registry.create(val++);
+    registry.assign<int>(registry.create(), val++);
+    registry.assign<int>(registry.create(), val++);
+    registry.assign<int>(registry.create(), val++);
 
     for(auto entity: registry.view<int>()) {
         ASSERT_EQ(registry.get<int>(entity), --val);
@@ -445,9 +472,11 @@ TEST(DefaultRegistry, SortMulti) {
     unsigned int uval = 0u;
     int ival = 0;
 
-    registry.create(uval++, ival++);
-    registry.create(uval++, ival++);
-    registry.create(uval++, ival++);
+    for(auto i = 0; i < 3; ++i) {
+        const auto entity = registry.create();
+        registry.assign<unsigned int>(entity, uval++);
+        registry.assign<int>(entity, ival++);
+    }
 
     for(auto entity: registry.view<unsigned int>()) {
         ASSERT_EQ(registry.get<unsigned int>(entity), --uval);
@@ -472,7 +501,7 @@ TEST(DefaultRegistry, SortMulti) {
 TEST(DefaultRegistry, ComponentsWithTypesFromStandardTemplateLibrary) {
     // see #37 - the test shouldn't crash, that's all
     entt::DefaultRegistry registry;
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.assign<std::unordered_set<int>>(entity).insert(42);
     registry.destroy(entity);
 }
@@ -481,7 +510,7 @@ TEST(DefaultRegistry, ConstructWithComponents) {
     // it should compile, that's all
     entt::DefaultRegistry registry;
     const auto value = 0;
-    registry.create(value);
+    registry.assign<int>(registry.create(), value);
 }
 
 TEST(DefaultRegistry, MergeTwoRegistries) {
@@ -495,7 +524,9 @@ TEST(DefaultRegistry, MergeTwoRegistries) {
     auto merge = [&ref](const auto &view, auto &dst) {
         view.each([&](auto entity, const auto &component) {
             if(ref.find(entity) == ref.cend()) {
-                ref.emplace(entity, dst.create(component));
+                const auto other = dst.create();
+                dst.template assign<std::decay_t<decltype(component)>>(other, component);
+                ref.emplace(entity, other);
             } else {
                 using component_type = std::decay_t<decltype(component)>;
                 dst.template assign<component_type>(ref[entity], component);
@@ -503,11 +534,24 @@ TEST(DefaultRegistry, MergeTwoRegistries) {
         });
     };
 
-    src.create<int, float, double>();
-    src.create<char, float, int>();
+    auto e0 = src.create();
+    src.assign<int>(e0);
+    src.assign<float>(e0);
+    src.assign<double>(e0);
+
+    auto e1 = src.create();
+    src.assign<char>(e1);
+    src.assign<float>(e1);
+    src.assign<int>(e1);
+
+    auto e2 = dst.create();
+    dst.assign<int>(e2);
+    dst.assign<char>(e2);
+    dst.assign<double>(e2);
 
-    dst.create<int, char, double>();
-    dst.create<float, int>();
+    auto e3 = dst.create();
+    dst.assign<float>(e3);
+    dst.assign<int>(e3);
 
     auto eq = [](auto begin, auto end) { ASSERT_EQ(begin, end); };
     auto ne = [](auto begin, auto end) { ASSERT_NE(begin, end); };

test/entt/entity/snapshot.cpp

@@ -51,21 +51,21 @@ struct Foo {
 TEST(Snapshot, Dump) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
+    const auto e0 = registry.create();
     registry.assign<int>(e0, 42);
     registry.assign<char>(e0, 'c');
     registry.assign<double>(e0, .1);
 
-    auto e1 = registry.create();
+    const auto e1 = registry.create();
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
     registry.assign<int>(e2, 3);
 
-    auto e3 = registry.create();
+    const auto e3 = registry.create();
     registry.assign<char>(e3, '0');
     registry.attach<float>(e3, .3f);
 
-    auto e4 = registry.create();
+    const auto e4 = registry.create();
     registry.attach<AComponent>(e4);
 
     registry.destroy(e1);
@@ -140,21 +140,21 @@ TEST(Snapshot, Dump) {
 TEST(Snapshot, Partial) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
+    const auto e0 = registry.create();
     registry.assign<int>(e0, 42);
     registry.assign<char>(e0, 'c');
     registry.assign<double>(e0, .1);
 
-    auto e1 = registry.create();
+    const auto e1 = registry.create();
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
     registry.assign<int>(e2, 3);
 
-    auto e3 = registry.create();
+    const auto e3 = registry.create();
     registry.assign<char>(e3, '0');
     registry.attach<float>(e3, .3f);
 
-    auto e4 = registry.create();
+    const auto e4 = registry.create();
     registry.attach<AComponent>(e4);
 
     registry.destroy(e1);

test/entt/entity/view.cpp

@@ -5,8 +5,11 @@
 TEST(View, SingleComponent) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     ASSERT_NO_THROW(registry.view<char>().begin()++);
     ASSERT_NO_THROW(++registry.view<char>().begin());
@@ -43,8 +46,11 @@ TEST(View, SingleComponent) {
 TEST(View, SingleComponentContains) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create<int>();
-    auto e1 = registry.create<int>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
 
     registry.destroy(e0);
 
@@ -57,8 +63,12 @@ TEST(View, SingleComponentContains) {
 TEST(View, SingleComponentEmpty) {
     entt::DefaultRegistry registry;
 
-    registry.create<char, double>();
-    registry.create<char>();
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+    registry.assign<double>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
 
     auto view = registry.view<int>();
 
@@ -73,8 +83,13 @@ TEST(View, SingleComponentEmpty) {
 TEST(View, SingleComponentEach) {
     entt::DefaultRegistry registry;
 
-    registry.create<int, char>();
-    registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     auto view = registry.view<int>();
     const auto &cview = static_cast<const decltype(view) &>(view);
@@ -92,8 +107,12 @@ TEST(View, SingleComponentEach) {
 TEST(View, MultipleComponent) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create<char>();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     auto it = registry.view<char>().begin();
 
@@ -131,8 +150,13 @@ TEST(View, MultipleComponent) {
 TEST(View, MultipleComponentContains) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create<int, char>();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     registry.destroy(e0);
 
@@ -145,8 +169,14 @@ TEST(View, MultipleComponentContains) {
 TEST(View, MultipleComponentEmpty) {
     entt::DefaultRegistry registry;
 
-    registry.create<double, int, float>();
-    registry.create<char, float>();
+    const auto e0 = registry.create();
+    registry.assign<double>(e0);
+    registry.assign<int>(e0);
+    registry.assign<float>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+    registry.assign<float>(e1);
 
     auto view = registry.view<char, int, float>();
 
@@ -159,8 +189,13 @@ TEST(View, MultipleComponentEmpty) {
 TEST(View, MultipleComponentEach) {
     entt::DefaultRegistry registry;
 
-    registry.create<int, char>();
-    registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     auto view = registry.view<int, char>();
     const auto &cview = static_cast<const decltype(view) &>(view);
@@ -179,8 +214,12 @@ TEST(PersistentView, Prepare) {
     entt::DefaultRegistry registry;
     registry.prepare<int, char>();
 
-    auto e0 = registry.create<char>();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     ASSERT_NO_THROW((registry.persistent<int, char>().begin()++));
     ASSERT_NO_THROW((++registry.persistent<int, char>().begin()));
@@ -220,8 +259,12 @@ TEST(PersistentView, Prepare) {
 TEST(PersistentView, NoPrepare) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create<char>();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     ASSERT_NO_THROW((registry.persistent<int, char>().begin()++));
     ASSERT_NO_THROW((++registry.persistent<int, char>().begin()));
@@ -261,8 +304,13 @@ TEST(PersistentView, NoPrepare) {
 TEST(PersistentView, Contains) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create<int, char>();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     registry.destroy(e0);
 
@@ -275,8 +323,14 @@ TEST(PersistentView, Contains) {
 TEST(PersistentView, Empty) {
     entt::DefaultRegistry registry;
 
-    registry.create<double, int, float>();
-    registry.create<char, float>();
+    const auto e0 = registry.create();
+    registry.assign<double>(e0);
+    registry.assign<int>(e0);
+    registry.assign<float>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+    registry.assign<float>(e1);
 
     for(auto entity: registry.persistent<char, int, float>()) {
         (void)entity;
@@ -293,8 +347,13 @@ TEST(PersistentView, Each) {
     entt::DefaultRegistry registry;
     registry.prepare<int, char>();
 
-    registry.create<int, char>();
-    registry.create<int, char>();
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     auto view = registry.persistent<int, char>();
     const auto &cview = static_cast<const decltype(view) &>(view);
@@ -313,9 +372,9 @@ TEST(PersistentView, Sort) {
     entt::DefaultRegistry registry;
     registry.prepare<int, unsigned int>();
 
-    auto e0 = registry.create();
-    auto e1 = registry.create();
-    auto e2 = registry.create();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+    const auto e2 = registry.create();
 
     auto uval = 0u;
     auto ival = 0;
@@ -347,8 +406,11 @@ TEST(PersistentView, Sort) {
 TEST(RawView, Functionalities) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
-    auto e1 = registry.create<int, char>();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
 
     ASSERT_NO_THROW(registry.raw<char>().begin()++);
     ASSERT_NO_THROW(++registry.raw<char>().begin());
@@ -393,8 +455,12 @@ TEST(RawView, Functionalities) {
 TEST(RawView, Empty) {
     entt::DefaultRegistry registry;
 
-    registry.create<char, double>();
-    registry.create<char>();
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+    registry.assign<double>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
 
     auto view = registry.raw<int>();
 

test/mod/mod.cpp

@@ -331,8 +331,12 @@ TEST(Mod, Duktape) {
         FAIL();
     }
 
-    registry.create(Position{ 0., 0. }, Renderable{});
-    registry.create(Position{ 0., 0. });
+    const auto e0 = registry.create();
+    registry.assign<Position>(e0, 0., 0.);
+    registry.assign<Renderable>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<Position>(e1, 0., 0.);
 
     const char *s1 = ""
             "Registry.entities(Types.POSITION, Types.RENDERABLE).forEach(function(entity) {"