pre-commit added

Author: Alexandre Hoffmann

include/xtensor/views/xslice.hpp

@@ -62,9 +62,8 @@ namespace xt
 
     template <class S>
     using is_xslice = std::is_base_of<xslice<S>, S>;
-
-    template <class E, class R = void>
-    using disable_xslice = typename std::enable_if<!is_xslice<E>::value, R>::type;
+    
+    template<class S> concept xslice_concept = is_xslice<S>::value;
 
     template <class... E>
     using has_xslice = std::disjunction<is_xslice<E>...>;
@@ -850,60 +849,64 @@ namespace xt
      ******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> get_size(const S&) noexcept
-    {
-        return 1;
-    }
-
-    template <class S>
-    inline auto get_size(const xslice<S>& slice) noexcept
+    inline std::size_t get_size(const S& slice) noexcept 
     {
-        return slice.derived_cast().size();
+			  if constexpr (is_xslice<S>::value)
+			  { 
+					return 1;
+				}
+				else
+				{
+					return slice.size();
+				}
     }
 
     /*******************************************************
      * homogeneous step_size for integral types and slices *
      *******************************************************/
 
     template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t) noexcept
-    {
-        return 0;
-    }
-
-    template <class S>
-    inline disable_xslice<S, std::size_t> step_size(const S&, std::size_t, std::size_t) noexcept
-    {
-        return 0;
-    }
-
-    template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx) noexcept
+    inline std::size_t step_size(const S& slice, std::size_t idx) noexcept
     {
-        return slice.derived_cast().step_size(idx);
+			  if constexpr (is_xslice<S>::value)
+			  {
+					return slice.step_size(idx);
+				}
+				else
+				{
+					return 0;
+				}
     }
 
     template <class S>
-    inline auto step_size(const xslice<S>& slice, std::size_t idx, std::size_t n) noexcept
+    inline std::size_t step_size(const xslice<S>& slice, std::size_t idx, std::size_t n) noexcept
     {
-        return slice.derived_cast().step_size(idx, n);
+        if constexpr (is_xslice<S>::value)
+			  {
+					return slice.step_size(idx, n);
+				}
+				else
+				{
+					return 0;
+				}
     }
 
     /*********************************************
      * homogeneous value for integral and slices *
      *********************************************/
 
-    template <class S, class I>
-    inline disable_xslice<S, std::size_t> value(const S& s, I) noexcept
-    {
-        return static_cast<std::size_t>(s);
-    }
-
     template <class S, class I>
     inline auto value(const xslice<S>& slice, I i) noexcept
     {
-        using ST = typename S::size_type;
-        return slice.derived_cast()(static_cast<ST>(i));
+			  if constexpr (is_xslice<S>::value)
+			  {
+					using ST = typename S::size_type;
+					return slice(static_cast<ST>(i));
+				}
+				else
+				{
+					return static_cast<std::size_t>(slice);
+				}
     }
 
     /****************************************

include/xtensor/views/xview.hpp

@@ -696,8 +696,8 @@ namespace xt
         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, class T, class... Args>
-        disable_xslice<T, size_type> sliced_access(const T& squeeze, Args...) const;
+        template <typename std::decay_t<CT>::size_type I, class T, class... Args> requires (!xslice_concept<T>)
+        size_type sliced_access(const T& squeeze, Args...) const;
 
         using base_index_type = xindex_type_t<typename xexpression_type::shape_type>;
 
@@ -1627,8 +1627,8 @@ namespace xt
     }
 
     template <class CT, class... S>
-    template <typename std::decay_t<CT>::size_type I, class T, class... Args>
-    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> disable_xslice<T, size_type>
+    template <typename std::decay_t<CT>::size_type I, class T, class... Args> requires (!xslice_concept<T>)
+    inline auto xview<CT, S...>::sliced_access(const T& squeeze, Args...) const -> size_type
     {
         return static_cast<size_type>(squeeze);
     }

include/xtensor/views/xview_utils.hpp

@@ -47,8 +47,8 @@ namespace xt
     template <class... S>
     constexpr std::size_t newaxis_skip(std::size_t i);
 
-    template <class S, class It>
-    inline disable_xslice<S, std::size_t> get_slice_value(const S& s, It&) noexcept
+    template <class S, class It> requires (!xslice_concept<S>)
+		inline std::size_t get_slice_value(const S& s, It&) noexcept
     {
         return static_cast<std::size_t>(s);
     }