CRTP for projection_base (#212)

Author: Morwenn

benchmarks/benchmarking-tools/distributions.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015-2024 Morwenn
+ * Copyright (c) 2015-2025 Morwenn
  * SPDX-License-Identifier: MIT
  */
 #include <algorithm>
@@ -472,7 +472,7 @@ namespace dist
     // Miscellaneous related tools
 
     struct as_long_string:
-        cppsort::utility::projection_base
+        cppsort::utility::projection_base<as_long_string>
     {
         auto operator()(long long int value) const
             -> std::string

docs/Chainable-projections.md

@@ -4,7 +4,7 @@ Sometimes one needs to apply several transformations to the elements of a collec
 
 ```cpp
 struct my_negate:
-    cppsort::utility::projection_base
+    cppsort::utility::projection_base<my_negate>
 {
     int operator()(int value) const
     {
@@ -13,7 +13,7 @@ struct my_negate:
 };
 ```
 
-Making a function object inherit from `utility::projection_base` allows it to benefit from the `operator|` overload used to compose projections; the projection inheriting from that class can appear on any side of the operator, and the other argument can be any suitable [*Callable*][callable]. Here is an example of what is possible with the custom projection defined above:
+Making a function object `F` inherit from `utility::projection_base<F>` allows it to benefit from the `operator|` overload used to compose projections; the projection inheriting from that class can appear on any side of the operator, and the other argument can be any suitable [*Callable*][callable]. Here is an example of what is possible with the custom projection defined above:
 
 ```cpp
 // Create a vector of wrapper

docs/Miscellaneous-utilities.md

@@ -159,7 +159,7 @@ This buffer provider allocates on the heap a number of elements depending on a g
 
 ***WARNING:** `utility::identity` is removed in version 2.0.0, use `std::identity` instead.*
 
-This header provides the class `projection_base` and the mechanism used to compose projections with `operator|`. See [Chainable projections][chainable-projections] for more information.
+This header provides the class template `projection_base` and the mechanism used to compose projections with `operator|`. See [Chainable projections][chainable-projections] for more information.
 
 Also available in this header, the struct `identity` is a function object that can type any value of any movable type and return it as is. It is used as a default for every projection parameter in the library so that sorters view the values as they are by default, without a modification.
 
@@ -181,7 +181,7 @@ Another simple yet very handy projection available in the header is `indirect`:
 
 ```cpp
 struct indirect:
-    projection_base
+    projection_base<indirect>
 {
     template<typename T>
     constexpr auto operator()(T&& indirect_value)

include/cpp-sort/utility/functional.h

@@ -26,15 +26,26 @@ namespace cppsort::utility
     ////////////////////////////////////////////////////////////
     // Base type to allow piping projections
 
-    // Literally just to check that other classes
-    // actually inherit from it
-    struct projection_base {};
+    // CRTP base class for all projection objects: it is modelled after
+    // std::ranges::range_adaptor_closure and thus uses CRTP for the same
+    // reason, namely to avoid having function objects bigger than they
+    // ought to (which happens when the same base class is inherited
+    // from several times by the same class)
+
+    template<typename Derived>
+    struct projection_base
+    {
+        static_assert(
+            std::is_object_v<Derived> &&
+            std::is_same_v<Derived, std::remove_cv_t<Derived>>
+        );
+    };
 
     namespace detail
     {
         template<typename T, typename U>
         struct projection_base_pipe_result:
-            projection_base,
+            projection_base<projection_base_pipe_result<T, U>>,
             cppsort::detail::raw_check_is_transparent<T, U>
         {
             T lhs;
@@ -67,8 +78,13 @@ namespace cppsort::utility
         typename T,
         typename U,
         typename = cppsort::detail::enable_if_t<
-            std::is_base_of_v<projection_base, cppsort::detail::remove_cvref_t<T>> ||
-            std::is_base_of_v<projection_base, cppsort::detail::remove_cvref_t<U>>
+            std::is_base_of_v<
+                projection_base<std::remove_reference_t<T>>,
+                cppsort::detail::remove_cvref_t<T>
+            > || std::is_base_of_v<
+                projection_base<std::remove_reference_t<U>>,
+                cppsort::detail::remove_cvref_t<U>
+            >
         >
     >
     constexpr auto operator|(T&& lhs, U&& rhs)
@@ -86,7 +102,10 @@ namespace cppsort::utility
     template<
         typename T,
         typename = cppsort::detail::enable_if_t<
-            std::is_base_of_v<projection_base, cppsort::detail::remove_cvref_t<T>>
+            std::is_base_of_v<
+                projection_base<std::remove_reference_t<T>>,
+                cppsort::detail::remove_cvref_t<T>
+            >
         >
     >
     constexpr auto operator|(T&& lhs, std::identity)
@@ -98,7 +117,10 @@ namespace cppsort::utility
     template<
         typename T,
         typename = cppsort::detail::enable_if_t<
-            std::is_base_of_v<projection_base, cppsort::detail::remove_cvref_t<T>>
+            std::is_base_of_v<
+                projection_base<std::remove_reference_t<T>>,
+                cppsort::detail::remove_cvref_t<T>
+            >
         >
     >
     constexpr auto operator|(std::identity, T&& rhs)
@@ -112,7 +134,7 @@ namespace cppsort::utility
     // Identity (mostly useful for projections)
 
     struct identity:
-        projection_base
+        projection_base<identity>
     {
         template<typename T>
         constexpr auto operator()(T&& value) const noexcept
@@ -153,7 +175,7 @@ namespace cppsort::utility
     // indirect
 
     struct indirect:
-        projection_base
+        projection_base<indirect>
     {
         template<typename T>
         constexpr auto operator()(T&& indirect_value)
@@ -177,7 +199,7 @@ namespace cppsort::utility
     {
         template<typename Function>
         struct as_projection_fn:
-            projection_base,
+            projection_base<as_projection_fn<Function>>,
             cppsort::detail::raw_check_is_transparent<Function>
         {
             private:
@@ -335,7 +357,7 @@ namespace cppsort::utility
     // Math functions (mostly useful for buffer providers)
 
     struct half:
-        projection_base
+        projection_base<half>
     {
         template<typename T>
         constexpr auto operator()(T&& value) const
@@ -348,7 +370,7 @@ namespace cppsort::utility
     };
 
     struct log:
-        projection_base
+        projection_base<log>
     {
         template<typename T>
         constexpr auto operator()(T&& value) const
@@ -362,7 +384,7 @@ namespace cppsort::utility
     };
 
     struct sqrt:
-        projection_base
+        projection_base<sqrt>
     {
         template<typename T>
         constexpr auto operator()(T&& value) const

tests/utility/chainable_projections.cpp

@@ -18,7 +18,7 @@ using wrapper = generic_wrapper<int>;
 namespace
 {
     struct proj1:
-        cppsort::utility::projection_base
+        cppsort::utility::projection_base<proj1>
     {
         auto operator()(int value) const
             -> int
@@ -28,7 +28,7 @@ namespace
     };
 
     struct proj2:
-        cppsort::utility::projection_base
+        cppsort::utility::projection_base<proj2>
     {
         auto operator()(int value)
             -> int