Support simple projections

Author: Morwenn

README.md

@@ -12,18 +12,29 @@ See also the following links for a detailed description of TimSort:
 
 According to the benchmarks, it is a bit slower than `std::sort()` on randomized sequences, but much faster on
 partially-sorted ones. `gfx::timsort` should be usable as a drop-in replacement for `std::stable_sort`, with the
-difference that it's can't fallback to a O(n log² n) algorithm when there isn't enough extra heap memory available.
+difference that it can't fallback to a O(n log² n) algorithm when there isn't enough extra heap memory available.
+
+Additionally `gfx::timsort` can take a [projection function](https://ezoeryou.github.io/blog/article/2019-01-22-ranges-projection.html)
+after the comparison function. The support is a bit rougher than in the linked article: only instances of types
+callable with parenthesis can be used, there is no support for pointer to members.
 
 ## EXAMPLE
 
+Example using timsort with a comparison function and a projection function to sort a vector of strings by length:
+
 ```cpp
 #include <string>
 #include <vector>
 #include <gfx/timsort.hpp>
 
-std::vector<std::string> a;
-// ... initialize a ...
-gfx::timsort(a.begin(), a.end(), std::less<string>());
+size_t len(const std::string& str) {
+    return str.size();
+}
+
+// Sort a vector of strings by length
+std::vector<std::string> vec;
+// ... fill vec ...
+gfx::timsort(vec.begin(), vec.end(), std::less<size_t>(), &len);
 ```
 
 ## COMPATIBILITY

include/gfx/timsort.hpp

@@ -103,6 +103,52 @@ namespace gfx {
 
 namespace detail {
 
+// Equivalent to C++20 std::identity
+struct identity {
+#if GFX_TIMSORT_USE_STD_MOVE
+    template <typename T>
+    T&& operator()(T&& value) const
+    {
+        return std::forward<T>(value);
+    }
+#else
+    template <typename T>
+    T& operator()(T& value) const {
+        return value;
+    }
+
+    template <typename T>
+    T const& operator()(T const& value) const {
+        return value;
+    }
+#endif
+};
+
+// Merge a predicate and a projection function
+template <typename Compare, typename Projection>
+struct projection_compare {
+    projection_compare(Compare comp, Projection proj) : compare(comp), projection(proj) {
+    }
+
+#if GFX_TIMSORT_USE_STD_MOVE
+    template <typename T, typename U>
+    bool operator()(T &&lhs, U &&rhs) {
+        return static_cast<bool>(compare(
+            projection(std::forward<T>(lhs)),
+            projection(std::forward<U>(rhs))
+        ));
+    }
+#else
+    template <typename T, typename U>
+    bool operator()(T &lhs, U &rhs) {
+        return static_cast<bool>(compare(projection(lhs), projection(rhs)));
+    }
+#endif
+
+    Compare compare;
+    Projection projection;
+};
+
 template <typename Iterator> struct run {
     typedef typename std::iterator_traits<Iterator>::difference_type diff_t;
 
@@ -669,12 +715,23 @@ template <typename RandomAccessIterator, typename Compare> class TimSort {
 // Public interface implementation
 // ---------------------------------------
 
+/**
+ * Stably sorts a range with a comparison function and a projection function.
+ */
+template <typename RandomAccessIterator, typename Compare, typename Projection>
+void timsort(RandomAccessIterator const first, RandomAccessIterator const last,
+             Compare compare, Projection projection) {
+    typedef detail::projection_compare<Compare, Projection> compare_t;
+    compare_t comp(compare, projection);
+    detail::TimSort<RandomAccessIterator, compare_t>::sort(first, last, comp);
+}
+
 /**
  * Same as std::stable_sort(first, last, compare).
  */
 template <typename RandomAccessIterator, typename Compare>
 void timsort(RandomAccessIterator const first, RandomAccessIterator const last, Compare compare) {
-    detail::TimSort<RandomAccessIterator, Compare>::sort(first, last, compare);
+    gfx::timsort(first, last, compare, detail::identity());
 }
 
 /**
@@ -683,7 +740,7 @@ void timsort(RandomAccessIterator const first, RandomAccessIterator const last,
 template <typename RandomAccessIterator>
 void timsort(RandomAccessIterator const first, RandomAccessIterator const last) {
     typedef typename std::iterator_traits<RandomAccessIterator>::value_type value_type;
-    gfx::timsort(first, last, std::less<value_type>());
+    gfx::timsort(first, last, std::less<value_type>(), detail::identity());
 }
 
 } // namespace gfx

tests/cxx_98_tests.cpp

@@ -516,3 +516,18 @@ TEST_CASE( "issue2_duplication" ) {
     CHECK(a[1001].first == expected[1001].first);
     CHECK(a[1001].second == expected[1001].second);
 }
+
+TEST_CASE( "projection" ) {
+    const int size = 128;
+
+    std::vector<int> vec;
+    for (int i = 0; i < size; ++i) {
+        vec.push_back(i - 40);
+    }
+    std::random_shuffle(vec.begin(), vec.end());
+
+    gfx::timsort(vec.begin(), vec.end(), std::greater<int>(), std::negate<int>());
+    for (int i = 0; i < size; ++i) {
+        CHECK(vec[i] == i - 40);
+    }
+}