remove storage_type from xcontiguous_iterable

Author: gouarin

include/xtensor/xiterable.hpp

@@ -245,23 +245,53 @@ namespace xt
 
     namespace detail
     {
-        template <class C>
-        struct linear_iterator_traits
+        template <class T, bool is_const>
+        struct get_storage_iterator;
+
+        template <class T>
+        struct get_storage_iterator<T, true>
         {
-            using iterator = typename C::iterator;
-            using const_iterator = typename C::const_iterator;
-            using reverse_iterator = typename C::reverse_iterator;
-            using const_reverse_iterator = typename C::const_reverse_iterator;
+            using iterator = typename T::const_iterator;
+            using const_iterator = typename T::const_iterator;
+            using reverse_iterator = typename T::const_reverse_iterator;
+            using const_reverse_iterator = typename T::const_reverse_iterator;
         };
 
-        template <class C>
-        struct linear_iterator_traits<const C>
+        template <class T>
+        struct get_storage_iterator<T, false>
+        {
+            using iterator = typename T::iterator;
+            using const_iterator = typename T::const_iterator;
+            using reverse_iterator = typename T::reverse_iterator;
+            using const_reverse_iterator = typename T::const_reverse_iterator;
+        };
+
+        template <class D, bool has_storage_type>
+        struct linear_iterator_traits_impl;
+
+        template <class D>
+        struct linear_iterator_traits_impl<D, true>
         {
-            using iterator = typename C::const_iterator;
-            using const_iterator = iterator;
-            using reverse_iterator = typename C::const_reverse_iterator;
-            using const_reverse_iterator = reverse_iterator;
+            using inner_types = xcontainer_inner_types<D>;
+            using storage_type = typename inner_types::storage_type;
+            using iterator_type = get_storage_iterator<storage_type, std::is_const<storage_type>::value>;
+            using linear_iterator = typename iterator_type::iterator;
+            using const_linear_iterator = typename iterator_type::const_iterator;
+            using reverse_linear_iterator = typename iterator_type::reverse_iterator;
+            using const_reverse_linear_iterator = typename iterator_type::const_reverse_iterator;
         };
+
+        template <class D>
+        struct linear_iterator_traits_impl<D, false>
+        {
+            using linear_iterator = typename D::linear_iterator;
+            using const_linear_iterator = typename D::const_linear_iterator;
+            using reverse_linear_iterator = typename D::reverse_linear_iterator;
+            using const_reverse_linear_iterator = typename D::const_reverse_linear_iterator;
+        };
+
+        template <class D>
+        using linear_iterator_traits = linear_iterator_traits_impl<D, has_storage_type<D>::value>;
     }
 
     /**
@@ -283,7 +313,6 @@ namespace xt
         using derived_type = D;
 
         using inner_types = xcontainer_inner_types<D>;
-        using storage_type = typename inner_types::storage_type;
 
         using iterable_base = xiterable<D>;
         using stepper = typename iterable_base::stepper;
@@ -321,11 +350,11 @@ namespace xt
         template <class S, layout_type L>
         using const_reverse_broadcast_iterator = typename iterable_base::template const_reverse_broadcast_iterator<S, L>;
 
-        using storage_traits = detail::linear_iterator_traits<storage_type>;
-        using linear_iterator = typename storage_traits::iterator;
-        using const_linear_iterator = typename storage_traits::const_iterator;
-        using reverse_linear_iterator = typename storage_traits::reverse_iterator;
-        using const_reverse_linear_iterator = typename storage_traits::const_reverse_iterator;
+        using linear_traits = detail::linear_iterator_traits<D>;
+        using linear_iterator = typename linear_traits::linear_iterator;
+        using const_linear_iterator = typename linear_traits::const_linear_iterator;
+        using reverse_linear_iterator = typename linear_traits::reverse_linear_iterator;
+        using const_reverse_linear_iterator = typename linear_traits::const_reverse_linear_iterator;
 
         template <layout_type L, class It1, class It2>
         using select_iterator_impl = std::conditional_t<L == static_layout, It1, It2>;

include/xtensor/xutils.hpp

@@ -574,6 +574,21 @@ namespace xt
     {
         return N;
     }
+    /***********************************
+     * has_storage_type implementation *
+     ***********************************/
+
+    template <class T, class = void>
+    struct has_storage_type : std::false_type
+    {};
+
+    template<class T>
+    struct xcontainer_inner_types;
+
+    template <class T>
+    struct has_storage_type<T, void_t<typename xcontainer_inner_types<T>::storage_type>>
+        : std::true_type
+    {};
 
     /*************************************
      * has_data_interface implementation *

test/test_xutils.cpp

@@ -132,6 +132,16 @@ namespace xt
         EXPECT_FALSE(b);
     }
 
+    TEST(utils, has_storage_type)
+    {
+        bool b = has_storage_type<xarray<int>>::value;
+        EXPECT_TRUE(b);
+
+        xarray<int> x, y;
+        b = has_storage_type<decltype(x + y)>::value;
+        EXPECT_FALSE(b);
+    }
+
     TEST(utils, has_strides)
     {
         bool b = has_strides<xarray<int>>::value;