diff options
| -rw-r--r-- | include/multi_span.h | 44 | ||||
| -rw-r--r-- | tests/multi_span_tests.cpp | 72 | ||||
| -rw-r--r-- | tests/strided_span_tests.cpp | 40 |
3 files changed, 78 insertions, 78 deletions
diff --git a/include/multi_span.h b/include/multi_span.h index cfe2d5c..a59c4dc 100644 --- a/include/multi_span.h +++ b/include/multi_span.h @@ -1127,25 +1127,25 @@ namespace details }; template <typename T, typename... Args> - T static_as_span_helper(Sep, Args... args) + T static_as_multi_span_helper(Sep, Args... args) { return T{narrow_cast<typename T::size_type>(args)...}; } template <typename T, typename Arg, typename... Args> std::enable_if_t< !std::is_same<Arg, dim<dynamic_range>>::value && !std::is_same<Arg, Sep>::value, T> - static_as_span_helper(Arg, Args... args) + static_as_multi_span_helper(Arg, Args... args) { - return static_as_span_helper<T>(args...); + return static_as_multi_span_helper<T>(args...); } template <typename T, typename... Args> - T static_as_span_helper(dim<dynamic_range> val, Args... args) + T static_as_multi_span_helper(dim<dynamic_range> val, Args... args) { - return static_as_span_helper<T>(args..., val.dvalue); + return static_as_multi_span_helper<T>(args..., val.dvalue); } template <typename... Dimensions> - struct static_as_span_static_bounds_helper + struct static_as_multi_span_static_bounds_helper { using type = static_bounds<(Dimensions::value)...>; }; @@ -1599,13 +1599,13 @@ public: template <typename SpanType, typename... Dimensions2, size_t DimCount = sizeof...(Dimensions2), bool Enabled = (DimCount > 0), typename = std::enable_if_t<Enabled>> constexpr multi_span<typename SpanType::value_type, Dimensions2::value...> -as_span(SpanType s, Dimensions2... dims) +as_multi_span(SpanType s, Dimensions2... dims) { static_assert(details::is_multi_span<SpanType>::value, - "Variadic as_span() is for reshaping existing spans."); + "Variadic as_multi_span() is for reshaping existing spans."); using BoundsType = typename multi_span<typename SpanType::value_type, (Dimensions2::value)...>::bounds_type; - auto tobounds = details::static_as_span_helper<BoundsType>(dims..., details::Sep{}); + auto tobounds = details::static_as_multi_span_helper<BoundsType>(dims..., details::Sep{}); details::verifyBoundsReshape(s.bounds(), tobounds); return {s.data(), tobounds}; } @@ -1636,7 +1636,7 @@ multi_span<byte> as_writeable_bytes(multi_span<U, Dimensions...> s) noexcept // on all implementations. It should be considered an experimental extension // to the standard GSL interface. template <typename U, std::ptrdiff_t... Dimensions> -constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span< +constexpr auto as_multi_span(multi_span<const byte, Dimensions...> s) noexcept -> multi_span< const U, static_cast<std::ptrdiff_t>( multi_span<const byte, Dimensions...>::bounds_type::static_size != dynamic_range ? (static_cast<size_t>( @@ -1661,7 +1661,7 @@ constexpr auto as_span(multi_span<const byte, Dimensions...> s) noexcept -> mult // on all implementations. It should be considered an experimental extension // to the standard GSL interface. template <typename U, std::ptrdiff_t... Dimensions> -constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept +constexpr auto as_multi_span(multi_span<byte, Dimensions...> s) noexcept -> multi_span<U, narrow_cast<std::ptrdiff_t>( multi_span<byte, Dimensions...>::bounds_type::static_size != dynamic_range ? static_cast<std::size_t>( @@ -1682,49 +1682,49 @@ constexpr auto as_span(multi_span<byte, Dimensions...> s) noexcept } template <typename T, std::ptrdiff_t... Dimensions> -constexpr auto as_span(T* const& ptr, dim<Dimensions>... args) +constexpr auto as_multi_span(T* const& ptr, dim<Dimensions>... args) -> multi_span<std::remove_all_extents_t<T>, Dimensions...> { return {reinterpret_cast<std::remove_all_extents_t<T>*>(ptr), - details::static_as_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})}; + details::static_as_multi_span_helper<static_bounds<Dimensions...>>(args..., details::Sep{})}; } template <typename T> -constexpr auto as_span(T* arr, std::ptrdiff_t len) -> +constexpr auto as_multi_span(T* arr, std::ptrdiff_t len) -> typename details::SpanArrayTraits<T, dynamic_range>::type { return {reinterpret_cast<std::remove_all_extents_t<T>*>(arr), len}; } template <typename T, size_t N> -constexpr auto as_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type +constexpr auto as_multi_span(T (&arr)[N]) -> typename details::SpanArrayTraits<T, N>::type { return {arr}; } template <typename T, size_t N> -constexpr multi_span<const T, N> as_span(const std::array<T, N>& arr) +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>& arr) { return {arr}; } template <typename T, size_t N> -constexpr multi_span<const T, N> as_span(const std::array<T, N>&&) = delete; +constexpr multi_span<const T, N> as_multi_span(const std::array<T, N>&&) = delete; template <typename T, size_t N> -constexpr multi_span<T, N> as_span(std::array<T, N>& arr) +constexpr multi_span<T, N> as_multi_span(std::array<T, N>& arr) { return {arr}; } template <typename T> -constexpr multi_span<T, dynamic_range> as_span(T* begin, T* end) +constexpr multi_span<T, dynamic_range> as_multi_span(T* begin, T* end) { return {begin, end}; } template <typename Cont> -constexpr auto as_span(Cont& arr) -> std::enable_if_t< +constexpr auto as_multi_span(Cont& arr) -> std::enable_if_t< !details::is_multi_span<std::decay_t<Cont>>::value, multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> { @@ -1733,13 +1733,13 @@ constexpr auto as_span(Cont& arr) -> std::enable_if_t< } template <typename Cont> -constexpr auto as_span(Cont&& arr) -> std::enable_if_t< +constexpr auto as_multi_span(Cont&& arr) -> std::enable_if_t< !details::is_multi_span<std::decay_t<Cont>>::value, multi_span<std::remove_reference_t<decltype(arr.size(), *arr.data())>, dynamic_range>> = delete; // from basic_string which doesn't have nonconst .data() member like other contiguous containers template <typename CharT, typename Traits, typename Allocator> -constexpr auto as_span(std::basic_string<CharT, Traits, Allocator>& str) +constexpr auto as_multi_span(std::basic_string<CharT, Traits, Allocator>& str) -> multi_span<CharT, dynamic_range> { Expects(str.size() < PTRDIFF_MAX); diff --git a/tests/multi_span_tests.cpp b/tests/multi_span_tests.cpp index 207428d..7432057 100644 --- a/tests/multi_span_tests.cpp +++ b/tests/multi_span_tests.cpp @@ -680,22 +680,22 @@ SUITE(multi_span_tests) { static_assert(Bounds::static_size == 60, "static bounds is wrong size"); } - TEST(as_span_reshape) + TEST(as_multi_span_reshape) { int a[3][4][5]; - auto av = as_span(a); + auto av = as_multi_span(a); fn(av.bounds()); - auto av2 = as_span(av, dim<60>()); - auto av3 = as_span(av2, dim<3>(), dim<4>(), dim<5>()); - auto av4 = as_span(av3, dim<4>(), dim<>(3), dim<5>()); - auto av5 = as_span(av4, dim<3>(), dim<4>(), dim<5>()); - auto av6 = as_span(av5, dim<12>(), dim<>(5)); + auto av2 = as_multi_span(av, dim<60>()); + auto av3 = as_multi_span(av2, dim<3>(), dim<4>(), dim<5>()); + auto av4 = as_multi_span(av3, dim<4>(), dim<>(3), dim<5>()); + auto av5 = as_multi_span(av4, dim<3>(), dim<4>(), dim<5>()); + auto av6 = as_multi_span(av5, dim<12>(), dim<>(5)); fill(av6.begin(), av6.end(), 1); auto av7 = as_bytes(av6); - auto av8 = as_span<int>(av7); + auto av8 = as_multi_span<int>(av7); CHECK(av8.size() == av6.size()); for (auto i = 0; i < av8.size(); i++) { @@ -949,12 +949,12 @@ SUITE(multi_span_tests) { { int arr[10][2]; - auto s1 = as_span(arr); + auto s1 = as_multi_span(arr); multi_span<const int, dynamic_range, 2> s2 = s1; CHECK(s1 == s2); - multi_span<int, 20> s3 = as_span(s1, dim<>(20)); + multi_span<int, 20> s3 = as_multi_span(s1, dim<>(20)); CHECK(s3 == s2 && s3 == s1); } @@ -1059,7 +1059,7 @@ SUITE(multi_span_tests) TEST(basics) { - auto ptr = as_span(new int[10], 10); + auto ptr = as_multi_span(new int[10], 10); fill(ptr.begin(), ptr.end(), 99); for (int num : ptr) { CHECK(num == 99); @@ -1071,7 +1071,7 @@ SUITE(multi_span_tests) TEST(bounds_checks) { int arr[10][2]; - auto av = as_span(arr); + auto av = as_multi_span(arr); fill(begin(av), end(av), 0); @@ -1111,7 +1111,7 @@ SUITE(multi_span_tests) { auto data = new int[4][3][5]; - auto av = as_span(data, 4); + auto av = as_multi_span(data, 4); CHECK(av.size() == 60); @@ -1122,7 +1122,7 @@ SUITE(multi_span_tests) CHECK(count == 34 * 60); overloaded_func(av, 34); - overloaded_func(as_span(av, dim<>(4), dim<>(3), dim<>(5)), 34); + overloaded_func(as_multi_span(av, dim<>(4), dim<>(3), dim<>(5)), 34); // fixed_func(av, 34); delete[] data; @@ -1137,7 +1137,7 @@ SUITE(multi_span_tests) // size check will be done auto image_view = - as_span(as_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>()); + as_multi_span(as_multi_span(image_ptr, imgSize), dim<>(height), dim<>(width), dim<3>()); iota(image_view.begin(), image_view.end(), 1); @@ -1160,12 +1160,12 @@ SUITE(multi_span_tests) } } - TEST(as_span) + TEST(as_multi_span) { { int* arr = new int[150]; - auto av = as_span(arr, dim<10>(), dim<>(3), dim<5>()); + auto av = as_multi_span(arr, dim<10>(), dim<>(3), dim<5>()); fill(av.begin(), av.end(), 24); overloaded_func(av, 24); @@ -1173,44 +1173,44 @@ SUITE(multi_span_tests) delete[] arr; array<int, 15> stdarr{0}; - auto av2 = as_span(stdarr); - overloaded_func(as_span(av2, dim<>(1), dim<3>(), dim<5>()), 0); + auto av2 = as_multi_span(stdarr); + overloaded_func(as_multi_span(av2, dim<>(1), dim<3>(), dim<5>()), 0); string str = "ttttttttttttttt"; // size = 15 auto t = str.data(); (void) t; - auto av3 = as_span(str); - overloaded_func(as_span(av3, dim<>(1), dim<3>(), dim<5>()), 't'); + auto av3 = as_multi_span(str); + overloaded_func(as_multi_span(av3, dim<>(1), dim<3>(), dim<5>()), 't'); } { string str; - multi_span<char> strspan = as_span(str); + multi_span<char> strspan = as_multi_span(str); (void) strspan; const string cstr; - multi_span<const char> cstrspan = as_span(cstr); + multi_span<const char> cstrspan = as_multi_span(cstr); (void) cstrspan; } { int a[3][4][5]; - auto av = as_span(a); + auto av = as_multi_span(a); const int(*b)[4][5]; b = a; - auto bv = as_span(b, 3); + auto bv = as_multi_span(b, 3); CHECK(av == bv); const std::array<double, 3> arr = {0.0, 0.0, 0.0}; - auto cv = as_span(arr); + auto cv = as_multi_span(arr); (void) cv; vector<float> vec(3); - auto dv = as_span(vec); + auto dv = as_multi_span(vec); (void) dv; #ifdef CONFIRM_COMPILATION_ERRORS - auto dv2 = as_span(std::move(vec)); + auto dv2 = as_multi_span(std::move(vec)); #endif } } @@ -1258,7 +1258,7 @@ SUITE(multi_span_tests) CHECK(av[i] == 4); - auto av2 = as_span(av, dim<4>(), dim<>(2)); + auto av2 = as_multi_span(av, dim<4>(), dim<>(2)); ptrdiff_t a2[2] = {0, 1}; index<2> i2 = a2; @@ -1486,21 +1486,21 @@ SUITE(multi_span_tests) arr[i] = i; } - auto av = as_span(arr, size); + auto av = as_multi_span(arr, size); // first bound is dynamic { - multi_span<int, dynamic_range, 2> av2 = as_span(av, dim<>(height), dim<>(width)); + multi_span<int, dynamic_range, 2> av2 = as_multi_span(av, dim<>(height), dim<>(width)); iterate_second_column(av2); } // second bound is dynamic { - multi_span<int, 4, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width)); + multi_span<int, 4, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width)); iterate_second_column(av2); } // both bounds are dynamic { - multi_span<int, dynamic_range, dynamic_range> av2 = as_span(av, dim<>(height), dim<>(width)); + multi_span<int, dynamic_range, dynamic_range> av2 = as_multi_span(av, dim<>(height), dim<>(width)); iterate_second_column(av2); } @@ -1521,7 +1521,7 @@ SUITE(multi_span_tests) CHECK_THROW(av1[10][3][4], fail_fast); - multi_span<const double, dynamic_range, 6, 4> av2 = as_span(av1, dim<>(5), dim<6>(), dim<4>()); + multi_span<const double, dynamic_range, 6, 4> av2 = as_multi_span(av1, dim<>(5), dim<6>(), dim<4>()); (void) av2; } @@ -1562,13 +1562,13 @@ SUITE(multi_span_tests) #ifdef CONFIRM_COMPILATION_ERRORS { multi_span<int, dynamic_range> av = arr; - multi_span<int, 2, 1> av2 = av.as_span(dim<2>(), dim<2>()); + multi_span<int, 2, 1> av2 = av.as_multi_span(dim<2>(), dim<2>()); } #endif { multi_span<int, dynamic_range> av = arr; - multi_span<int, 2, 1> av2 = as_span(av, dim<>(2), dim<>(2)); + multi_span<int, 2, 1> av2 = as_multi_span(av, dim<>(2), dim<>(2)); auto workaround_macro = [&]() { return av2[{1, 0}] == 2; }; CHECK(workaround_macro()); } diff --git a/tests/strided_span_tests.cpp b/tests/strided_span_tests.cpp index 9fcdfeb..19056b1 100644 --- a/tests/strided_span_tests.cpp +++ b/tests/strided_span_tests.cpp @@ -39,7 +39,7 @@ SUITE(strided_span_tests) { int a[30][4][5]; - auto av = as_span(a); + auto av = as_multi_span(a); auto sub = av.section({15, 0, 0}, gsl::index<3>{2, 2, 2}); auto subsub = sub.section({1, 0, 0}, gsl::index<3>{1, 1, 1}); (void)subsub; @@ -49,7 +49,7 @@ SUITE(strided_span_tests) { std::vector<int> data(5 * 10); std::iota(begin(data), end(data), 0); - const multi_span<int, 5, 10> av = as_span(multi_span<int>{data}, dim<5>(), dim<10>()); + const multi_span<int, 5, 10> av = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); strided_span<int, 2> av_section_1 = av.section({ 1, 2 }, { 3, 4 }); CHECK((av_section_1[{0, 0}] == 12)); @@ -258,7 +258,7 @@ SUITE(strided_span_tests) { std::vector<int> data(5 * 10); std::iota(begin(data), end(data), 0); - const multi_span<int, 5, 10> src = as_span(multi_span<int>{data}, dim<5>(), dim<10>()); + const multi_span<int, 5, 10> src = as_multi_span(multi_span<int>{data}, dim<5>(), dim<10>()); const strided_span<int, 2> sav{ src, {{5, 10}, {10, 1}} }; #ifdef CONFIRM_COMPILATION_ERRORS @@ -413,18 +413,18 @@ SUITE(strided_span_tests) strided_span<int, 1> sav2{ arr, { 1,1,1 } }; strided_span<int, 1> sav3{ av, { 1 } }; strided_span<int, 1> sav4{ av, { 1,1,1 } }; - strided_span<int, 2> sav5{ av.as_span(dim<2>(), dim<2>()), { 1 } }; - strided_span<int, 2> sav6{ av.as_span(dim<2>(), dim<2>()), { 1,1,1 } }; - strided_span<int, 2> sav7{ av.as_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; + strided_span<int, 2> sav5{ av.as_multi_span(dim<2>(), dim<2>()), { 1 } }; + strided_span<int, 2> sav6{ av.as_multi_span(dim<2>(), dim<2>()), { 1,1,1 } }; + strided_span<int, 2> sav7{ av.as_multi_span(dim<2>(), dim<2>()), { { 1,1 },{ 1,1 },{ 1,1 } } }; index<1> index{ 0, 1 }; strided_span<int, 1> sav8{ arr,{ 1,{ 1,1 } } }; strided_span<int, 1> sav9{ arr,{ { 1,1 },{ 1,1 } } }; strided_span<int, 1> sav10{ av,{ 1,{ 1,1 } } }; strided_span<int, 1> sav11{ av,{ { 1,1 },{ 1,1 } } }; - strided_span<int, 2> sav12{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; - strided_span<int, 2> sav13{ av.as_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; - strided_span<int, 2> sav14{ av.as_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; + strided_span<int, 2> sav12{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1 } } }; + strided_span<int, 2> sav13{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1 },{ 1,1,1 } } }; + strided_span<int, 2> sav14{ av.as_multi_span(dim<2>(), dim<2>()),{ { 1,1,1 },{ 1 } } }; } #endif } @@ -463,7 +463,7 @@ SUITE(strided_span_tests) // retype strided array with regular strides - from multi_span { strided_bounds<2> bounds{ { 2, bytes.size() / 4 }, { bytes.size() / 2, 1 } }; - multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; strided_span<int, 2> sav3 = sav2.as_strided_span<int>(); CHECK(sav3[0][0] == 0); @@ -475,7 +475,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - last dimension of the array is too small { strided_bounds<2> bounds{ { 4,2 },{ 4, 1 } }; - multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -483,7 +483,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - strides are too small { strided_bounds<2> bounds{ { 4,2 },{ 2, 1 } }; - multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -491,7 +491,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - last dimension does not divide by the new typesize { strided_bounds<2> bounds{ { 2,6 },{ 4, 1 } }; - multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -499,7 +499,7 @@ SUITE(strided_span_tests) // retype strided array with not enough elements - strides does not divide by the new typesize { strided_bounds<2> bounds{ { 2, 1 },{ 6, 1 } }; - multi_span<const byte, 2, dynamic_range> bytes2 = as_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); + multi_span<const byte, 2, dynamic_range> bytes2 = as_multi_span(bytes, dim<2>(), dim<>(bytes.size() / 2)); strided_span<const byte, 2> sav2{ bytes2, bounds }; CHECK_THROW(sav2.as_strided_span<int>(), fail_fast); } @@ -606,7 +606,7 @@ SUITE(strided_span_tests) arr[2 * i + 1] = i; } - auto av = as_span(arr, 8); + auto av = as_multi_span(arr, 8); iterate_every_other_element(av); delete[] arr; @@ -670,22 +670,22 @@ SUITE(strided_span_tests) } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<>(3), dim<4>(), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<>(3), dim<4>(), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<>(4), dim<2>()); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<>(4), dim<2>()); iterate_second_slice(av); } { - auto av = as_span(as_span(arr, 24), dim<3>(), dim<4>(), dim<>(2)); + auto av = as_multi_span(as_multi_span(arr, 24), dim<3>(), dim<4>(), dim<>(2)); iterate_second_slice(av); } delete[] arr; @@ -704,7 +704,7 @@ SUITE(strided_span_tests) auto d1 = sizeof(int) * 12 / d2; // convert to 4x12 array of bytes - auto av = as_span(as_bytes(as_span(arr, 4)), dim<>(d1), dim<>(d2)); + auto av = as_multi_span(as_bytes(as_multi_span(arr, 4)), dim<>(d1), dim<>(d2)); CHECK(av.bounds().index_bounds()[0] == 4); CHECK(av.bounds().index_bounds()[1] == 12); |