storage/registry: review range ::insert (breaking change)

src/entt/entity/registry.hpp

@@ -577,13 +577,12 @@ public:
      * @param first An iterator to the first element of the range of entities.
      * @param last An iterator past the last element of the range of entities.
      * @param from An iterator to the first element of the range of components.
-     * @param to An iterator past the last element of the range of components.
      */
-    template<typename Component, typename EIt, typename CIt>
-    void insert(EIt first, EIt last, CIt from, CIt to) {
+    template<typename Component, typename EIt, typename CIt, typename = std::enable_if_t<std::is_same_v<std::decay_t<typename std::iterator_traits<CIt>::value_type>, Component>>>
+    void insert(EIt first, EIt last, CIt from) {
         static_assert(std::is_constructible_v<Component, typename std::iterator_traits<CIt>::value_type>, "Invalid value type");
         ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); }), "Invalid entity");
-        assure<Component>()->insert(*this, first, last, from, to);
+        assure<Component>()->insert(*this, first, last, from);
     }
 
     /**

src/entt/entity/storage.hpp

@@ -563,15 +563,15 @@ public:
      * @param first An iterator to the first element of the range of entities.
      * @param last An iterator past the last element of the range of entities.
      * @param from An iterator to the first element of the range of objects.
-     * @param to An iterator past the last element of the range of objects.
      */
-    template<typename EIt, typename CIt>
-    void insert(EIt first, EIt last, CIt from, CIt to) {
+    template<typename EIt, typename CIt, typename = std::enable_if_t<std::is_same_v<std::decay_t<typename std::iterator_traits<CIt>::value_type>, value_type>>>
+    void insert(EIt first, EIt last, CIt from) {
         if(const auto length = underlying_type::insert(first, last); length) {
-            maybe_resize_packed(count + length);
+            const auto sz = count + length;
+            maybe_resize_packed(sz);
 
-            for(; from != to; ++from) {
-                push_back(*from);
+            while(count != sz) {
+                push_back(*(from++));
             }
         }
     }

test/entt/entity/poly_storage.cpp

@@ -53,7 +53,7 @@ struct PolyStorage: entt::type_list_cat_t<
 
         static void copy_to(const Type &self, entt::basic_registry<entity_type> &other) {
             const entt::sparse_set &base = self;
-            other.template insert<typename Type::value_type>(base.rbegin(), base.rend(), self.rbegin(), self.rend());
+            other.template insert<typename Type::value_type>(base.rbegin(), base.rend(), self.rbegin());
         }
     };
 

test/entt/entity/registry.cpp

@@ -1269,7 +1269,7 @@ TEST(Registry, Insert) {
     float value[3]{0.f, 1.f, 2.f};
 
     const auto iview = registry.view<int>();
-    registry.insert<float>(iview.data(), iview.data() + iview.size(), value, value + iview.size());
+    registry.insert<float>(iview.data(), iview.data() + iview.size(), value);
 
     ASSERT_EQ(registry.get<float>(e0), 0.f);
     ASSERT_EQ(registry.get<float>(e1), 1.f);

test/entt/entity/storage.cpp

@@ -451,7 +451,7 @@ TEST(Storage, SortOrdered) {
     entt::entity entities[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{12}, {9}, {6}, {3}, {1}};
 
-    pool.insert(std::begin(entities), std::end(entities), std::begin(values), std::end(values));
+    pool.insert(std::begin(entities), std::end(entities), values);
     pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
 
     ASSERT_TRUE(std::equal(std::rbegin(entities), std::rend(entities), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -463,7 +463,7 @@ TEST(Storage, SortReverse) {
     entt::entity entities[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{1}, {3}, {6}, {9}, {12}};
 
-    pool.insert(std::begin(entities), std::end(entities), std::begin(values), std::end(values));
+    pool.insert(std::begin(entities), std::end(entities), values);
     pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
 
     ASSERT_TRUE(std::equal(std::begin(entities), std::end(entities), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -475,7 +475,7 @@ TEST(Storage, SortUnordered) {
     entt::entity entities[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{6}, {3}, {1}, {9}, {12}};
 
-    pool.insert(std::begin(entities), std::end(entities), std::begin(values), std::end(values));
+    pool.insert(std::begin(entities), std::end(entities), values);
     pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
 
     auto begin = pool.begin();
@@ -500,7 +500,7 @@ TEST(Storage, SortRange) {
     entt::entity entities[5u]{entt::entity{12}, entt::entity{42}, entt::entity{7}, entt::entity{3}, entt::entity{9}};
     boxed_int values[5u]{{3}, {6}, {1}, {9}, {12}};
 
-    pool.insert(std::begin(entities), std::end(entities), std::begin(values), std::end(values));
+    pool.insert(std::begin(entities), std::end(entities), values);
     pool.sort_n(0u, [](auto lhs, auto rhs) { return lhs.value < rhs.value; });
 
     ASSERT_TRUE(std::equal(std::rbegin(entities), std::rend(entities), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
@@ -541,7 +541,7 @@ TEST(Storage, RespectDisjoint) {
 
     entt::entity lhs_entities[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
     int lhs_values[3u]{3, 6, 9};
-    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), std::begin(lhs_values), std::end(lhs_values));
+    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), lhs_values);
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entities), std::rend(lhs_entities), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -558,11 +558,11 @@ TEST(Storage, RespectOverlap) {
 
     entt::entity lhs_entities[3u]{entt::entity{3}, entt::entity{12}, entt::entity{42}};
     int lhs_values[3u]{3, 6, 9};
-    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), std::begin(lhs_values), std::end(lhs_values));
+    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), lhs_values);
 
     entt::entity rhs_entities[1u]{entt::entity{12}};
     int rhs_values[1u]{6};
-    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), std::begin(rhs_values), std::end(rhs_values));
+    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), rhs_values);
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entities), std::rend(lhs_entities), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -591,11 +591,11 @@ TEST(Storage, RespectOrdered) {
 
     entt::entity lhs_entities[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
     int lhs_values[5u]{1, 2, 3, 4, 5};
-    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), std::begin(lhs_values), std::end(lhs_values));
+    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), lhs_values);
 
     entt::entity rhs_entities[6u]{entt::entity{6}, entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
     int rhs_values[6u]{6, 1, 2, 3, 4, 5};
-    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), std::begin(rhs_values), std::end(rhs_values));
+    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), rhs_values);
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entities), std::rend(lhs_entities), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -615,11 +615,11 @@ TEST(Storage, RespectReverse) {
 
     entt::entity lhs_entities[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
     int lhs_values[5u]{1, 2, 3, 4, 5};
-    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), std::begin(lhs_values), std::end(lhs_values));
+    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), lhs_values);
 
     entt::entity rhs_entities[6u]{entt::entity{5}, entt::entity{4}, entt::entity{3}, entt::entity{2}, entt::entity{1}, entt::entity{6}};
     int rhs_values[6u]{5, 4, 3, 2, 1, 6};
-    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), std::begin(rhs_values), std::end(rhs_values));
+    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), rhs_values);
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entities), std::rend(lhs_entities), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));
@@ -654,11 +654,11 @@ TEST(Storage, RespectUnordered) {
 
     entt::entity lhs_entities[5u]{entt::entity{1}, entt::entity{2}, entt::entity{3}, entt::entity{4}, entt::entity{5}};
     int lhs_values[5u]{1, 2, 3, 4, 5};
-    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), std::begin(lhs_values), std::end(lhs_values));
+    lhs.insert(std::begin(lhs_entities), std::end(lhs_entities), lhs_values);
 
     entt::entity rhs_entities[6u]{entt::entity{3}, entt::entity{2}, entt::entity{6}, entt::entity{1}, entt::entity{4}, entt::entity{5}};
     int rhs_values[6u]{3, 2, 6, 1, 4, 5};
-    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), std::begin(rhs_values), std::end(rhs_values));
+    rhs.insert(std::begin(rhs_entities), std::end(rhs_entities), rhs_values);
 
     ASSERT_TRUE(std::equal(std::rbegin(lhs_entities), std::rend(lhs_entities), lhs.entt::sparse_set::begin(), lhs.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(lhs_values), std::rend(lhs_values), lhs.begin(), lhs.end()));