Merge pull request #2251 from adriendelsalle/drop-old-clang-support

Drop support of 3.* Clang versions

Author: JohanMabille

docs/source/compilers.rst

@@ -70,6 +70,8 @@ Workarounds for this compiler bug arise in various files of the code base.
 Everywhere, the handling of `Clang < 3.8` is wrapped with checks for the
 ``X_OLD_CLANG`` macro.
 
+The support of `Clang < 4.0` is dropped in xtensor 0.22.
+
 GCC < 5.1 and ``std::is_trivially_default_constructible``
 ---------------------------------------------------------
 

include/xtensor/xadapt.hpp

@@ -396,21 +396,12 @@ namespace xt
         return return_type(buffer_type(pointer, detail::fixed_compute_size<fixed_shape<X...>>::value));
     }
 
-#ifndef X_OLD_CLANG
     template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C, class T,  std::size_t N>
     inline auto adapt(C&& ptr, const T(&shape)[N])
     {
         using shape_type = std::array<std::size_t, N>;
         return adapt(std::forward<C>(ptr), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
     }
-#else
-    template <layout_type L = XTENSOR_DEFAULT_LAYOUT, class C>
-    inline auto adapt(C&& ptr, std::initializer_list<std::size_t> shape)
-    {
-        using shape_type = xt::dynamic_shape<std::size_t>;
-        return adapt(std::forward<C>(ptr), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
-    }
-#endif
 
     /*****************************
      * smart_ptr adapter builder *
@@ -514,7 +505,6 @@ namespace xt
         );
     }
 
-#ifndef X_OLD_CLANG
     /**
      * Adapt a smart pointer to a typed memory block (unique_ptr or shared_ptr)
      *
@@ -608,7 +598,6 @@ namespace xt
             l
         );
     }
-#endif
 }
 
 #endif

include/xtensor/xbroadcast.hpp

@@ -38,13 +38,8 @@ namespace xt
     template <class E, class S>
     auto broadcast(E&& e, const S& s);
 
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    auto broadcast(E&& e, std::initializer_list<I> s);
-#else
     template <class E, class I, std::size_t L>
     auto broadcast(E&& e, const I (&s)[L]);
-#endif
 
     /*************************
      * xbroadcast extensions *
@@ -243,23 +238,13 @@ namespace xt
         return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(s)>(s));
     }
 
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    inline auto broadcast(E&& e, std::initializer_list<I> s)
-    {
-        using broadcast_type = xbroadcast<const_xclosure_t<E>, std::vector<std::size_t>>;
-        using shape_type = typename broadcast_type::shape_type;
-        return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(s)>(s));
-    }
-#else
     template <class E, class I, std::size_t L>
     inline auto broadcast(E&& e, const I (&s)[L])
     {
         using broadcast_type = xbroadcast<const_xclosure_t<E>, std::array<std::size_t, L>>;
         using shape_type = typename broadcast_type::shape_type;
         return broadcast_type(std::forward<E>(e), xtl::forward_sequence<shape_type, decltype(s)>(s));
     }
-#endif
 
     /*****************************
      * xbroadcast implementation *

include/xtensor/xbuilder.hpp

@@ -21,9 +21,6 @@
 #include <functional>
 #include <utility>
 #include <vector>
-#ifdef X_OLD_CLANG
-    #include <initializer_list>
-#endif
 
 #include <xtl/xclosure.hpp>
 #include <xtl/xsequence.hpp>
@@ -51,19 +48,11 @@ namespace xt
         return broadcast(T(1), std::forward<S>(shape));
     }
 
-#ifdef X_OLD_CLANG
-    template <class T, class I>
-    inline auto ones(std::initializer_list<I> shape) noexcept
-    {
-        return broadcast(T(1), shape);
-    }
-#else
     template <class T, class I, std::size_t L>
     inline auto ones(const I (&shape)[L]) noexcept
     {
         return broadcast(T(1), shape);
     }
-#endif
 
     /*********
      * zeros *
@@ -79,19 +68,11 @@ namespace xt
         return broadcast(T(0), std::forward<S>(shape));
     }
 
-#ifdef X_OLD_CLANG
-    template <class T, class I>
-    inline auto zeros(std::initializer_list<I> shape) noexcept
-    {
-        return broadcast(T(0), shape);
-    }
-#else
     template <class T, class I, std::size_t L>
     inline auto zeros(const I (&shape)[L]) noexcept
     {
         return broadcast(T(0), shape);
     }
-#endif
 
     /**
      * Create a xcontainer (xarray, xtensor or xtensor_fixed) with uninitialized values of
@@ -117,20 +98,12 @@ namespace xt
         return xtensor<T, N, L>(xtl::forward_sequence<shape_type, decltype(shape)>(shape));
     }
 
-#ifndef X_OLD_CLANG
     template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, class I, std::size_t N>
     inline xtensor<T, N, L> empty(const I(&shape)[N])
     {
         using shape_type = typename xtensor<T, N>::shape_type;
         return xtensor<T, N, L>(xtl::forward_sequence<shape_type, decltype(shape)>(shape));
     }
-#else
-    template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, class I>
-    inline xarray<T, L> empty(const std::initializer_list<I>& init)
-    {
-        return xarray<T, L>::from_shape(init);
-    }
-#endif
 
     template <class T, layout_type L = XTENSOR_DEFAULT_LAYOUT, std::size_t... N>
     inline xtensor_fixed<T, fixed_shape<N...>, L> empty(const fixed_shape<N...>& /*shape*/)
@@ -900,7 +873,7 @@ namespace xt
         template <std::size_t... I, class... E>
         inline auto meshgrid_impl(std::index_sequence<I...>, E&&... e) noexcept
         {
-#if defined X_OLD_CLANG || defined _MSC_VER
+#if defined _MSC_VER
             const std::array<std::size_t, sizeof...(E)> shape = {e.shape()[0]...};
             return std::make_tuple(
                 detail::make_xgenerator(

include/xtensor/xgenerator.hpp

@@ -484,23 +484,13 @@ namespace xt
 
     namespace detail
     {
-#ifdef X_OLD_CLANG
-        template <class Functor, class I>
-        inline auto make_xgenerator(Functor&& f, std::initializer_list<I> shape) noexcept
-        {
-            using shape_type = std::vector<std::size_t>;
-            using type = xgenerator<Functor, typename Functor::value_type, shape_type>;
-            return type(std::forward<Functor>(f), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
-        }
-#else
         template <class Functor, class I, std::size_t L>
         inline auto make_xgenerator(Functor&& f, const I (&shape)[L]) noexcept
         {
             using shape_type = std::array<std::size_t, L>;
             using type = xgenerator<Functor, typename Functor::value_type, shape_type>;
             return type(std::forward<Functor>(f), xtl::forward_sequence<shape_type, decltype(shape)>(shape));
         }
-#endif
 
         template <class Functor, class S>
         inline auto make_xgenerator(Functor&& f, S&& shape) noexcept

include/xtensor/xindex_view.hpp

@@ -753,26 +753,13 @@ namespace xt
         using view_type = xindex_view<xclosure_t<E>, std::decay_t<I>>;
         return view_type(std::forward<E>(e), std::forward<I>(indices));
     }
-#ifdef X_OLD_CLANG
-    template <class E, class I>
-    inline auto index_view(E&& e, std::initializer_list<std::initializer_list<I>> indices) noexcept
-    {
-        std::vector<xindex> idx;
-        for (auto it = indices.begin(); it != indices.end(); ++it)
-        {
-            idx.emplace_back(xindex(it->begin(), it->end()));
-        }
-        using view_type = xindex_view<xclosure_t<E>, std::vector<xindex>>;
-        return view_type(std::forward<E>(e), std::move(idx));
-    }
-#else
+
     template <class E, std::size_t L>
     inline auto index_view(E&& e, const xindex (&indices)[L]) noexcept
     {
         using view_type = xindex_view<xclosure_t<E>, std::array<xindex, L>>;
         return view_type(std::forward<E>(e), to_array(indices));
     }
-#endif
 
     /**
      * @brief creates a view into \a e filtered by \a condition.

include/xtensor/xmanipulation.hpp

@@ -238,20 +238,11 @@ namespace xt
     }
 
     /// @cond DOXYGEN_INCLUDE_SFINAE
-#ifdef X_OLD_CLANG
-    template <class E, class I, class Tag = check_policy::none>
-    inline auto transpose(E&& e, std::initializer_list<I> permutation, Tag check_policy = Tag())
-    {
-        dynamic_shape<I> perm(permutation);
-        return detail::transpose_impl(std::forward<E>(e), std::move(perm), check_policy);
-    }
-#else
     template <class E, class I, std::size_t N, class Tag = check_policy::none>
     inline auto transpose(E&& e, const I(&permutation)[N], Tag check_policy = Tag())
     {
         return detail::transpose_impl(std::forward<E>(e), permutation, check_policy);
     }
-#endif
     /// @endcond
 
     /************************************
@@ -449,21 +440,12 @@ namespace xt
     }
 
     /// @cond DOXYGEN_INCLUDE_SFINAE
-#ifdef X_OLD_CLANG
-    template <class E, class I, class Tag = check_policy::none>
-    inline auto squeeze(E&& e, std::initializer_list<I> axis, Tag check_policy = Tag())
-    {
-        dynamic_shape<I> ax(axis);
-        return detail::squeeze_impl(std::forward<E>(e), std::move(ax), check_policy);
-    }
-#else
     template <class E, class I, std::size_t N, class Tag = check_policy::none>
     inline auto squeeze(E&& e, const I(&axis)[N], Tag check_policy = Tag())
     {
         using arr_t = std::array<I, N>;
         return detail::squeeze_impl(std::forward<E>(e), xtl::forward_sequence<arr_t, decltype(axis)>(axis), check_policy);
     }
-#endif
 
     template <class E, class Tag = check_policy::none>
     inline auto squeeze(E&& e, std::size_t axis, Tag check_policy = Tag())