storage: removed ::sort, capture pool and use ::get if needed

src/entt/entity/registry.hpp

@@ -1436,7 +1436,8 @@ public:
     template<typename Component, typename Compare, typename Sort = std_sort, typename... Args>
     void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
         ENTT_ASSERT(sortable<Component>(), "Cannot sort owned storage");
-        assure<Component>()->sort(std::move(compare), std::move(algo), std::forward<Args>(args)...);
+        auto *cpool = assure<Component>();
+        cpool->sort_n(cpool->size(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
     }
 
     /**

src/entt/entity/storage.hpp

@@ -686,31 +686,13 @@ public:
     void sort_n(const size_type length, Compare compare, Sort algo = Sort{}, Args &&... args) {
         if constexpr(std::is_invocable_v<Compare, const value_type &, const value_type &>) {
             underlying_type::sort_n(length, [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
-                const auto ilhs = underlying_type::index(lhs), irhs = underlying_type::index(rhs);
-                return compare(std::as_const(packed[page(ilhs)][offset(ilhs)]), std::as_const(packed[page(irhs)][offset(irhs)]));
+                return compare(std::as_const(get(lhs)), std::as_const(get(rhs)));
             }, std::move(algo), std::forward<Args>(args)...);
         } else {
             underlying_type::sort_n(length, std::move(compare), std::move(algo), std::forward<Args>(args)...);
         }
     }
 
-    /**
-     * @brief Sort all elements according to the given comparison function.
-     *
-     * @sa sort_n
-     *
-     * @tparam Compare Type of comparison function object.
-     * @tparam Sort Type of sort function object.
-     * @tparam Args Types of arguments to forward to the sort function object.
-     * @param compare A valid comparison function object.
-     * @param algo A valid sort function object.
-     * @param args Arguments to forward to the sort function object, if any.
-     */
-    template<typename Compare, typename Sort = std_sort, typename... Args>
-    void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
-        sort_n(underlying_type::size(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
-    }
-
 private:
     compressed_pair<alloc, size_type> bucket;
     alloc_ptr_pointer packed;

test/entt/entity/storage.cpp

@@ -768,7 +768,7 @@ TEST(Storage, SortOrdered) {
     boxed_int values[5u]{{12}, {9}, {6}, {3}, {1}};
 
     pool.insert(std::begin(entities), std::end(entities), values);
-    pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
+    pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs).value < pool.get(rhs).value; });
 
     ASSERT_TRUE(std::equal(std::rbegin(entities), std::rend(entities), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::rbegin(values), std::rend(values), pool.begin(), pool.end()));
@@ -780,7 +780,7 @@ TEST(Storage, SortReverse) {
     boxed_int values[5u]{{1}, {3}, {6}, {9}, {12}};
 
     pool.insert(std::begin(entities), std::end(entities), values);
-    pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
+    pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs).value < pool.get(rhs).value; });
 
     ASSERT_TRUE(std::equal(std::begin(entities), std::end(entities), pool.entt::sparse_set::begin(), pool.entt::sparse_set::end()));
     ASSERT_TRUE(std::equal(std::begin(values), std::end(values), pool.begin(), pool.end()));
@@ -792,7 +792,7 @@ TEST(Storage, SortUnordered) {
     boxed_int values[5u]{{6}, {3}, {1}, {9}, {12}};
 
     pool.insert(std::begin(entities), std::end(entities), values);
-    pool.sort([](auto lhs, auto rhs) { return lhs.value < rhs.value; });
+    pool.sort([&pool](auto lhs, auto rhs) { return pool.get(lhs).value < pool.get(rhs).value; });
 
     auto begin = pool.begin();
     auto end = pool.end();