refactor: convert slices from CRTP to C++20 concepts

Use if constexpr with auto return types for slice helper functions.

Author: sbstndb

include/xtensor/views/xdynamic_view.hpp

@@ -324,7 +324,7 @@ namespace xt
     namespace detail
     {
         template <class T>
-        class xfake_slice : public xslice<xfake_slice<T>>
+        class xfake_slice
         {
         public:
 

include/xtensor/views/xslice.hpp

@@ -10,6 +10,7 @@
 #ifndef XTENSOR_SLICE_HPP
 #define XTENSOR_SLICE_HPP
 
+#include <concepts>
 #include <cstddef>
 #include <map>
 #include <type_traits>
@@ -35,33 +36,73 @@ namespace xt
 {
 
     /**********************
-     * xslice declaration *
+     * xslice type traits *
      **********************/
 
-    template <class D>
-    class xslice
+    // Forward declarations
+    template <class T>
+    class xrange;
+
+    template <class T>
+    class xstepped_range;
+
+    template <class T>
+    class xall;
+
+    template <class T>
+    class xnewaxis;
+
+    template <class T>
+    class xkeep_slice;
+
+    template <class T>
+    class xdrop_slice;
+
+    namespace detail
     {
-    public:
+        template <class S>
+        struct is_xslice_impl : std::false_type
+        {
+        };
+
+        template <class T>
+        struct is_xslice_impl<xrange<T>> : std::true_type
+        {
+        };
 
-        using derived_type = D;
+        template <class T>
+        struct is_xslice_impl<xstepped_range<T>> : std::true_type
+        {
+        };
 
-        derived_type& derived_cast() noexcept;
-        const derived_type& derived_cast() const noexcept;
+        template <class T>
+        struct is_xslice_impl<xall<T>> : std::true_type
+        {
+        };
 
-    protected:
+        template <class T>
+        struct is_xslice_impl<xnewaxis<T>> : std::true_type
+        {
+        };
 
-        xslice() = default;
-        ~xslice() = default;
+        template <class T>
+        struct is_xslice_impl<xkeep_slice<T>> : std::true_type
+        {
+        };
 
-        xslice(const xslice&) = default;
-        xslice& operator=(const xslice&) = default;
+        template <class T>
+        struct is_xslice_impl<xdrop_slice<T>> : std::true_type
+        {
+        };
+    }
 
-        xslice(xslice&&) = default;
-        xslice& operator=(xslice&&) = default;
+    template <class S>
+    struct is_xslice : detail::is_xslice_impl<S>
+    {
     };
 
     template <class S>
-    using is_xslice = std::is_base_of<xslice<S>, S>;
+    concept xslice_concept = is_xslice<S>::value;
 
     template <class... E>
     using has_xslice = std::disjunction<is_xslice<E>...>;
@@ -99,7 +140,7 @@ namespace xt
      **********************/
 
     template <class T>
-    class xrange : public xslice<xrange<T>>
+    class xrange
     {
     public:
 
@@ -143,7 +184,7 @@ namespace xt
      ******************************/
 
     template <class T>
-    class xstepped_range : public xslice<xstepped_range<T>>
+    class xstepped_range
     {
     public:
 
@@ -188,7 +229,7 @@ namespace xt
      ********************/
 
     template <class T>
-    class xall : public xslice<xall<T>>
+    class xall
     {
     public:
 
@@ -259,7 +300,7 @@ namespace xt
      ************************/
 
     template <class T>
-    class xnewaxis : public xslice<xnewaxis<T>>
+    class xnewaxis
     {
     public:
 
@@ -320,7 +361,7 @@ namespace xt
     }
 
     template <class T>
-    class xkeep_slice : public xslice<xkeep_slice<T>>
+    class xkeep_slice
     {
     public:
 
@@ -428,7 +469,7 @@ namespace xt
     }
 
     template <class T>
-    class xdrop_slice : public xslice<xdrop_slice<T>>
+    class xdrop_slice
     {
     public:
 
@@ -778,14 +819,11 @@ namespace xt
     template <class S>
     inline std::size_t get_size(const S& slice) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.size();
         }
-        else
-        {
-            return 1;
-        }
+        return 1;
     }
 
     /*******************************************************
@@ -795,37 +833,31 @@ namespace xt
     template <class S>
     inline std::size_t step_size(const S& slice, std::size_t idx) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.step_size(idx);
         }
-        else
-        {
-            return 0;
-        }
+        return 0;
     }
 
     template <class S>
     inline std::size_t step_size(const S& slice, std::size_t idx, std::size_t n) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice.step_size(idx, n);
         }
-        else
-        {
-            return 0;
-        }
+        return 0;
     }
 
     /*********************************************
      * homogeneous value for integral and slices *
      *********************************************/
 
     template <class S, class I>
-    inline std::size_t value(const S& slice, I i) noexcept
+    inline auto value(const S& slice, I i) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             using ST = typename S::size_type;
             return slice(static_cast<ST>(i));
@@ -966,22 +998,6 @@ namespace xt
     template <class E, class SL>
     using get_slice_type = typename detail::get_slice_type_impl<E, std::remove_reference_t<SL>>::type;
 
-    /*************************
-     * xslice implementation *
-     *************************/
-
-    template <class D>
-    inline auto xslice<D>::derived_cast() noexcept -> derived_type&
-    {
-        return *static_cast<derived_type*>(this);
-    }
-
-    template <class D>
-    inline auto xslice<D>::derived_cast() const noexcept -> const derived_type&
-    {
-        return *static_cast<const derived_type*>(this);
-    }
-
     /*************************
      * xrange implementation *
      *************************/

include/xtensor/views/xview.hpp

@@ -713,11 +713,11 @@ namespace xt
         template <typename std::decay_t<CT>::size_type I, class... Args>
         size_type index(Args... args) const;
 
-        template <typename std::decay_t<CT>::size_type, class T>
-        size_type sliced_access(const xslice<T>& slice) const;
+        template <typename std::decay_t<CT>::size_type I, xslice_concept T>
+        size_type sliced_access(const T& slice) const;
 
-        template <typename std::decay_t<CT>::size_type I, class T, class Arg, class... Args>
-        size_type sliced_access(const xslice<T>& slice, Arg arg, Args... args) const;
+        template <typename std::decay_t<CT>::size_type I, xslice_concept T, class Arg, class... Args>
+        size_type sliced_access(const T& slice, Arg arg, Args... args) const;
 
         template <typename std::decay_t<CT>::size_type I, class T, class... Args>
         size_type sliced_access(const T& squeeze, Args...) const
@@ -1657,20 +1657,18 @@ namespace xt
     }
 
     template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class T>
-    inline auto xview<CT, S...>::sliced_access(const xslice<T>& slice) const -> size_type
+    template <typename std::decay_t<CT>::size_type I, xslice_concept T>
+    inline auto xview<CT, S...>::sliced_access(const T& slice) const -> size_type
     {
-        return static_cast<size_type>(slice.derived_cast()(0));
+        return static_cast<size_type>(slice(0));
     }
 
     template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class T, class Arg, class... Args>
-    inline auto xview<CT, S...>::sliced_access(const xslice<T>& slice, Arg arg, Args... args) const -> size_type
+    template <typename std::decay_t<CT>::size_type I, xslice_concept T, class Arg, class... Args>
+    inline auto xview<CT, S...>::sliced_access(const T& slice, Arg arg, Args... args) const -> size_type
     {
         using ST = typename T::size_type;
-        return static_cast<size_type>(
-            slice.derived_cast()(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...))
-        );
+        return static_cast<size_type>(slice(argument<I>(static_cast<ST>(arg), static_cast<ST>(args)...)));
     }
 
     template <class CT, class... S>

include/xtensor/views/xview_utils.hpp

@@ -50,7 +50,7 @@ namespace xt
     template <class S, class It>
     inline auto get_slice_value(const S& slice, It& it) noexcept
     {
-        if constexpr (is_xslice<S>::value)
+        if constexpr (xslice_concept<S>)
         {
             return slice(typename S::size_type(*it));
         }