making adapt(std::array) return xfixed_adaptor.

include/xtensor/xadapt.hpp

@@ -35,6 +35,12 @@ namespace xt
             static constexpr std::size_t value = N;
         };
 
+        template <class T, std::size_t N>
+        struct array_size_impl<const_array<T, N>>
+        {
+            static constexpr std::size_t value = N;
+        };
+
         template <class C>
         using array_size = array_size_impl<std::decay_t<C>>;
 
@@ -209,7 +215,8 @@ namespace xt
      * @param container the container to adapt
      * @param l the layout_type of the xtensor_adaptor
      */
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C,
+              XTL_REQUIRES(detail::not_an_array<std::decay_t<C>>)>
     inline xtensor_adaptor<C, 1, L>
     adapt(C&& container, layout_type l = L)
     {
@@ -218,6 +225,22 @@ namespace xt
         return return_type(std::forward<C>(container), shape, l);
     }
 
+    /**
+     * Constructs a 1-D xtensor_adaptor of the given stl-like container,
+     * with the specified layout_type.
+     * @param container the container to adapt
+     * @param l the layout_type of the xtensor_adaptor
+     */
+    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C,
+              XTL_REQUIRES(detail::is_array<std::decay_t<C>>)>
+    inline auto
+    adapt(C&& container)
+    {
+        // const std::array<typename std::decay_t<C>::size_type, 1> shape{container.size()};
+        using return_type = xfixed_adaptor<xtl::closure_type_t<C>, fixed_shape<std::tuple_size<std::decay_t<C>>::value>, L>;
+        return return_type(std::forward<C>(container));
+    }
+
     /**
      * Constructs an xtensor_adaptor of the given stl-like container,
      * with the specified shape and layout_type.

include/xtensor/xcontainer.hpp

@@ -52,6 +52,14 @@ namespace xt
         {
             using type = std::allocator<T>;  // fake allocator for testing
         };
+
+
+        template <class T, std::size_t N>
+        struct allocator_type_impl<const_array<T, N>>
+        {
+            using type = std::allocator<T>;  // fake allocator for testing
+        };
+
     }
 
     template <class T>

include/xtensor/xfixed.hpp

@@ -400,7 +400,7 @@ namespace xt
     struct xcontainer_inner_types<xfixed_adaptor<EC, S, L, SH, Tag>>
     {
         using storage_type = std::remove_reference_t<EC>;
-        using reference = typename storage_type::reference;
+        using reference = inner_reference_t<storage_type>;
         using const_reference = typename storage_type::const_reference;
         using size_type = typename storage_type::size_type;
         using shape_type = S;

include/xtensor/xshape.hpp

@@ -351,6 +351,12 @@ namespace xt
         {
             static constexpr bool value = true;
         };
+
+        template <class T, std::size_t N>
+        struct is_array<const_array<T, N>>
+        {
+            static constexpr bool value = true;
+        };
 
         template <class S>
         struct is_fixed : std::false_type

test/test_xadapt.cpp

@@ -418,6 +418,23 @@ namespace xt
         }
     }
 
+    TEST(xtensor_fixed_adaptor, array)
+    {
+        std::array<int, 8> a({1,2,3,4,5,6,7,8});
+        auto xa = adapt(a);
+        xa(0) = 100;
+        xa(3) = 1000;
+        EXPECT_EQ(a[0], 100);
+        EXPECT_EQ(a[3], 1000);
+        bool truthy = std::is_same<decltype(xa)::shape_type, xshape<8>>::value;
+        EXPECT_TRUE(truthy);
+
+        const std::array<int, 4> b({5,5,19,5});
+        auto xb = adapt(b);
+        EXPECT_EQ(xb(2), 19);
+        EXPECT_EQ(xb(0), 5);
+    }
+
     namespace xadapt_test
     {
         struct Buffer {