Merge branch 'develop' into flattened-refactored

Author: alfC

include/boost/multi/array_ref.hpp

@@ -1311,9 +1311,9 @@ class const_subarray : public array_types<T, D, ElementPtr, Layout> {
 	using element_cref                                 = typename std::iterator_traits<element_const_ptr>::reference;
 
  private:
-	using index_gen [[deprecated("here to fulfill MultiArray concept")]]    = char*;
-	using extent_gen [[deprecated("here to fulfill MultiArray concept")]]   = void;
-	using extent_range [[deprecated("here to fulfill MultiArray concept")]] = void;
+	using index_gen [[deprecated("here to fulfill backward-compatible MultiArray concept")]]    = char*;
+	using extent_gen [[deprecated("here to fulfill backward-compatible  MultiArray concept")]]  = void;
+	using extent_range [[deprecated("here to fulfill backward-compatible MultiArray concept")]] = void;
 
 	// private:
 	using elements_iterator  = elements_iterator_t<element_ptr, layout_type>;
@@ -2254,17 +2254,17 @@ class subarray : public const_subarray<T, D, ElementPtr, Layout> {
 	}
 	template<class It> BOOST_MULTI_HD constexpr auto assign(It first) && -> It { return assign(first); }  // cppcheck-suppress duplInheritedMember ; to overwrite
 
-	template<class TT = typename subarray::element>
-	constexpr auto fill(TT const& value) & -> decltype(auto) {
-		return adl_fill_n(this->begin(), this->size(), value), *this;
-	}
-	constexpr auto fill() & -> decltype(auto) { return fill(typename subarray::element{}); }
+	// template<class TT = typename subarray::element>
+	// constexpr auto fill(TT const& value) & -> decltype(auto) {
+	// 	return adl_fill_n(this->begin(), this->size(), value), *this;
+	// }
+	// constexpr auto fill() & -> decltype(auto) { return fill(typename subarray::element{}); }
 
-	template<class TT = typename subarray::element>
-	[[deprecated]] constexpr auto fill(TT const& value) && -> decltype(auto) { return std::move(this->fill(value)); }
-	[[deprecated]] constexpr auto fill() && -> decltype(auto) {
-		return std::move(*this).fill(typename subarray::element{});
-	}
+	// template<class TT = typename subarray::element>
+	// [[deprecated]] constexpr auto fill(TT const& value) && -> decltype(auto) { return std::move(this->fill(value)); }
+	// [[deprecated]] constexpr auto fill() && -> decltype(auto) {
+	// 	return std::move(*this).fill(typename subarray::element{});
+	// }
 
 	using const_subarray<T, D, ElementPtr, Layout>::strided;
 	// cppcheck-suppress-begin duplInheritedMember ; to overwrite

include/boost/multi/detail/layout.hpp

@@ -1700,12 +1700,12 @@ struct layout_t
 	[[deprecated("use get<d>(m.extensions()")]]  // TODO(correaa) redeprecate, this is commented to give a smaller CI output
 	constexpr auto
 	extension(dimensionality_type dim) const {
-		return std::apply([](auto... extensions) -> auto { return std::array<index_extension, static_cast<std::size_t>(D)>{extensions...}; }, extensions().base()).at(static_cast<std::size_t>(dim));
+		return std::apply([](auto... extensions) -> auto { return std::array<index_extension, static_cast<std::size_t>(D)>{{extensions...}}; }, extensions().base()).at(static_cast<std::size_t>(dim));
 	}  // cppcheck-suppress syntaxError ; bug in cppcheck 2.14
 	   //  [[deprecated("use get<d>(m.strides())  ")]]  // TODO(correaa) redeprecate, this is commented to give a smaller CI output
-	constexpr auto stride(dimensionality_type dim) const {
-		return std::apply([](auto... strides) -> auto { return std::array<stride_type, static_cast<std::size_t>(D)>{strides...}; }, strides()).at(static_cast<std::size_t>(dim));
-	}
+	// constexpr auto stride(dimensionality_type dim) const {
+	// 	return std::apply([](auto... strides) -> auto { return std::array<stride_type, static_cast<std::size_t>(D)>{{strides...}}; }, strides()).at(static_cast<std::size_t>(dim));
+	// }
 	//  [[deprecated("use get<d>(m.sizes())    ")]]  // TODO(correaa) redeprecate, this is commented to give a smaller CI output
 	//  constexpr auto size     (dimensionality_type dim) const {return std::apply([](auto... sizes     ) {return std::array<size_type      , static_cast<std::size_t>(D)>{sizes     ...};}, sizes     ()       ).at(static_cast<std::size_t>(dim));}
 

include/boost/multi/utility.hpp

@@ -538,8 +538,6 @@ auto extents(Container const& cont) {
 	}
 }
 
-template<class T> struct has_shape : decltype(has_shape_aux(std::declval<T>())){};  // NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg,cppcoreguidelines-pro-bounds-array-to-pointer-decay,hicpp-no-array-decay) trick
-
 template<class T, typename = decltype(std::declval<T const&>().elements())>
 auto        has_elements_aux(T const&) -> std::true_type;
 inline auto has_elements_aux(...) -> std::false_type;
@@ -571,16 +569,6 @@ constexpr auto extensions_aux2(BoostMultiArray const& arr, std::index_sequence<I
 	);
 }
 
-template<class Element, class T, std::enable_if_t<has_extents<T>::value, int> = 0>  // NOLINT(modernize-use-constraints) TODO(correaa) in C++20
-[[nodiscard]] auto extents_of(T const& array) {
-	if constexpr(std::is_convertible_v<T const&, Element>) {
-		return boost::multi::extents_t<0>{};
-	}
-	if constexpr(std::is_convertible_v<typename T::reference, Element>) {
-		return boost::multi::extents_t<1>{array.extents()};
-	}
-}
-
 template<class Arr2D>
 auto transposed(Arr2D&& arr)
 	-> decltype(std::forward<Arr2D>(arr).transposed()) {
@@ -613,18 +601,6 @@ auto extents(T const& array) {
 	return extensions_aux<D>::call(array);
 }
 
-template<class T1> struct extensions_t_aux;
-
-template<class T1, class T2> auto extensions_me(T2 const& array) {
-	return extensions_t_aux<T1>::call(array);
-}
-
-template<class T1> struct extension_t_aux {
-	static auto call(T1 const& /*unused*/) { return std::make_tuple(); }
-	template<class T2>
-	static auto call(T2 const& array) { return tuple_cat(std::make_tuple(array.extent()), extensions_me<T1>(*begin(array))); }
-};
-
 template<class T, typename = decltype(std::declval<T const&>().layout())>
 auto        has_layout_member_aux(T const&) -> std::true_type;
 inline auto has_layout_member_aux(...) -> std::false_type;

test/element_transformed.cpp

@@ -11,8 +11,8 @@
 
 #include <boost/core/lightweight_test.hpp>  // IWYU pragma: keep
 
-// IWYU pragma: no_include <algorithm>                        // for copy  // for GNU stdlib
-// IWYU pragma: no_include <type_traits>                      // for declval  // for GNU stdlib
+#include <algorithm>  // for std::fill
+// IWYU pragma: no_include <type_traits>   // for declval  // for GNU stdlib
 #include <complex>   // IWYU pragma: keep  // for complex, operator*, operator+
 #include <iterator>  // IWYU pragma: keep  // for weakly_incrementable
 #include <utility>   // IWYU pragma: keep  // for declval, forward
@@ -267,7 +267,8 @@ auto main() -> int {  // NOLINT(readability-function-cognitive-complexity,bugpro
 		//  std::fill(indirect_v.begin(), indirect_v.end(), 88.0);
 
 #ifndef _MSC_VER
-		indirect_v.fill(880);
+		std::fill(indirect_v.begin(), indirect_v.end(), 880);  // NOLINT(modernize-use-ranges) for C++20
+		// indirect_v.fill(880);
 		BOOST_TEST(  vec[3] ==  880 );
 
 		auto const& const_indirect_v = indirect_v;

test/fill.cpp

@@ -117,7 +117,7 @@ auto main() -> int {  // NOLINT(readability-function-cognitive-complexity,bugpro
 		namespace multi = boost::multi;
 
 		multi::array<int, 1> d1D = {10, 20, 30, 40};
-		d1D.fill(420);
+		std::fill(d1D.begin(), d1D.end(), 420);  // NOLINT(modernize-use-ranges) for C++20
 
 		multi::array<int, 2> d2D = {
 			{1500, 160, 170, 180, 190},

test/subarray.cpp

@@ -303,6 +303,10 @@ auto main() -> int {  // NOLINT(readability-function-cognitive-complexity,bugpro
 			BOOST_TEST( &arr.apply(std::array<int, 1>{{1}})[1] == &arr[1][1] );
 		}
 	}
+	// {
+	// 	multi::array<int, 1> A({6}, 99);
+	// 	[[maybe_unused]] auto&& B = A.stride(2);  // ok, should not compile
+	// }
 
 	return boost::report_errors();
 }