Add a static extent template parameter to absl::Span `absl::Span<T, N>` refers to exactly N elements and stores only a pointer. `absl::Span<T>` is now shorthand for `absl::Span<T, absl::dynamic_extent>` and behaves as before. PiperOrigin-RevId: 1016273879
diff --git a/absl/algorithm/container.h b/absl/algorithm/container.h index 1db7da7..7af0a57 100644 --- a/absl/algorithm/container.h +++ b/absl/algorithm/container.h
@@ -65,7 +65,7 @@ namespace absl { ABSL_NAMESPACE_BEGIN -template <typename T> +template <typename T, size_t Extent> class Span; namespace container_algorithm_internal { @@ -201,8 +201,8 @@ : std::conditional_t<std::is_same_v<T, std::remove_cv_t<T>>, std::false_type, IsSpan<std::remove_cv_t<T>>> {}; -template <typename T> -struct IsSpan<absl::Span<T>> : std::true_type {}; +template <typename T, size_t Extent> +struct IsSpan<absl::Span<T, Extent>> : std::true_type {}; #ifdef __cpp_lib_span template <typename T, size_t Extent>
diff --git a/absl/types/internal/span.h b/absl/types/internal/span.h index f0f1af6..f6dec27 100644 --- a/absl/types/internal/span.h +++ b/absl/types/internal/span.h
@@ -17,6 +17,7 @@ #define ABSL_TYPES_INTERNAL_SPAN_H_ #include <algorithm> +#include <array> #include <cstddef> #include <string> #include <type_traits> @@ -28,7 +29,7 @@ namespace absl { ABSL_NAMESPACE_BEGIN -template <typename T> +template <typename T, size_t Extent> class Span; namespace span_internal { @@ -78,17 +79,17 @@ template <typename T> using EnableIfMutable = std::enable_if_t<!std::is_const_v<T>, int>; -template <template <typename> class SpanT, typename T> -constexpr bool EqualImpl(SpanT<T> a, SpanT<T> b) { - static_assert(std::is_const_v<T>); +template <typename SpanT> +constexpr bool EqualImpl(SpanT a, SpanT b) { + static_assert(std::is_const_v<typename SpanT::element_type>); return std::equal(a.begin(), a.end(), b.begin(), b.end()); } -template <template <typename> class SpanT, typename T> -constexpr bool LessThanImpl(SpanT<T> a, SpanT<T> b) { +template <typename SpanT> +constexpr bool LessThanImpl(SpanT a, SpanT b) { // We can't use value_type since that is remove_cv_t<T>, so we go the long way // around. - static_assert(std::is_const_v<T>); + static_assert(std::is_const_v<typename SpanT::element_type>); return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end()); } @@ -125,6 +126,20 @@ template <typename T> using EnableIfNotIsView = std::enable_if_t<!IsView<T>::value, int>; +// Detect `Span` and `std::array`, which static-extent spans convert from with +// dedicated constructors. +template <typename T> +struct IsSpan : std::false_type {}; + +template <typename T, size_t Extent> +struct IsSpan<Span<T, Extent>> : std::true_type {}; + +template <typename T> +struct IsStdArray : std::false_type {}; + +template <typename T, size_t N> +struct IsStdArray<std::array<T, N>> : std::true_type {}; + } // namespace span_internal ABSL_NAMESPACE_END } // namespace absl
diff --git a/absl/types/span.h b/absl/types/span.h index 41aba0a..4b4bcb9 100644 --- a/absl/types/span.h +++ b/absl/types/span.h
@@ -42,8 +42,10 @@ // assignment. // * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or // `as_writable_bytes()` methods -// * `absl::Span` has no static extent template parameter, nor constructors -// which exist only because of the static extent parameter. +// * `absl::Span<T, N>` supports a static extent like `std::span<T, N>`, but +// class template argument deduction and `MakeSpan()` always produce +// dynamic-extent spans, and static-extent spans have no relational +// operators of their own. // * `absl::Span` has an explicit mutable-reference constructor // * `absl::Span::subspan(pos, len)` always truncates `len` to // `size() - pos`, whereas `std::span::subspan()` only truncates when the @@ -54,6 +56,7 @@ #define ABSL_TYPES_SPAN_H_ #include <algorithm> +#include <array> #include <cassert> #include <cstddef> #include <initializer_list> @@ -76,7 +79,13 @@ namespace absl { ABSL_NAMESPACE_BEGIN -template <typename T> +// dynamic_extent +// +// The extent of a `Span` whose size is only known at runtime. +// `absl::Span<T>` is shorthand for `absl::Span<T, absl::dynamic_extent>`. +inline constexpr size_t dynamic_extent = static_cast<size_t>(-1); + +template <typename T, size_t Extent = dynamic_extent> class Span; ABSL_NAMESPACE_END @@ -89,12 +98,13 @@ #endif #if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L #include <ranges> // NOLINT(build/c++20) -template <typename T> +template <typename T, size_t Extent> // NOLINTNEXTLINE(build/c++20) -inline constexpr bool std::ranges::enable_view<absl::Span<T>> = true; -template <typename T> +inline constexpr bool std::ranges::enable_view<absl::Span<T, Extent>> = true; +template <typename T, size_t Extent> // NOLINTNEXTLINE(build/c++20) -inline constexpr bool std::ranges::enable_borrowed_range<absl::Span<T>> = true; +inline constexpr bool + std::ranges::enable_borrowed_range<absl::Span<T, Extent>> = true; #endif namespace absl { @@ -178,8 +188,24 @@ // // Explicit constructor from pointer,size // int* my_array = new int[10]; // MyRoutine(absl::Span<const int>(my_array, 10)); +// +// Static extents +// +// `Span<T, N>` refers to exactly `N` elements, like `std::span<T, N>`. Only +// conversions that cannot change the size are implicit: +// +// void SetKey(absl::Span<const uint8_t, 32> key); +// +// std::array<uint8_t, 32> key = ...; +// SetKey(key); // OK, implicit +// absl::Span<const uint8_t> dynamic = key; // OK, implicit +// SetKey(absl::Span<const uint8_t, 32>(dynamic)); // explicit, size checked +// SetKey(dynamic.first<32>()); // explicit, size checked +// +// The `Span<T>` documented below is the dynamic-extent case, +// `Span<T, dynamic_extent>`. The static-extent case is defined after it. template <typename T> -class ABSL_ATTRIBUTE_VIEW Span { +class ABSL_ATTRIBUTE_VIEW Span<T, dynamic_extent> { private: // Used to determine whether a Span can be constructed from a container of // type C. @@ -217,6 +243,7 @@ // NOLINTNEXTLINE static constexpr size_type npos = static_cast<size_type>(-1); + static constexpr size_type extent = dynamic_extent; constexpr Span() noexcept : Span(nullptr, 0) {} constexpr Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND, @@ -303,6 +330,16 @@ ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept // NOLINT(runtime/explicit) : Span(v.begin(), v.size()) {} + // Implicit conversion from a static-extent span, e.g. from `Span<int, 4>` to + // `Span<int>` or `Span<const int>`. + template <typename U, size_t N, + std::enable_if_t<N != dynamic_extent && + std::is_convertible_v<U (*)[], T (*)[]>, + int> = 0> + constexpr Span( // NOLINT(google-explicit-constructor) + Span<U, N> other) noexcept + : Span(other.data(), N) {} + // Accessors // Span::data() @@ -495,6 +532,40 @@ : (ThrowStdOutOfRange("len > size()"), Span()); } + // Span::first<Count>(), Span::last<Count>(), Span::subspan<Offset, Count>() + // + // Like `first()`, `last()` and `subspan()` above, but return a static-extent + // `Span<T, Count>`. Unlike `subspan(pos, len)`, `subspan<Offset, Count>()` + // never truncates: `Offset + Count` must be <= size(). Without a `Count`, the + // result is a dynamic-extent span holding the rest of the elements. + // + // Examples: + // + // std::vector<int> vec = {10, 11, 12, 13}; + // absl::MakeSpan(vec).first<2>(); // Span<int, 2>{10, 11} + // absl::MakeSpan(vec).last<1>(); // Span<int, 1>{13} + // absl::MakeSpan(vec).subspan<1, 2>(); // Span<int, 2>{11, 12} + // absl::MakeSpan(vec).subspan<1>(); // Span<int>{11, 12, 13} + // absl::MakeSpan(vec).first<5>(); // throws std::out_of_range + template <size_t Count> + constexpr Span<T, Count> first() const { + return Span<T, Count>(first(Count)); + } + + template <size_t Count> + constexpr Span<T, Count> last() const { + return Span<T, Count>(last(Count)); + } + + template <size_t Offset, size_t Count = dynamic_extent> + constexpr Span<T, Count> subspan() const { + if constexpr (Count == dynamic_extent) { + return subspan(Offset); + } else { + return subspan(Offset).template first<Count>(); + } + } + // Support for absl::Hash. template <typename H> friend H AbslHashValue(H h, Span v) { @@ -506,6 +577,220 @@ size_type len_; }; +//------------------------------------------------------------------------------ +// Span<T, Extent> +//------------------------------------------------------------------------------ +// +// A `Span` with a static extent refers to exactly `Extent` elements. The size +// is part of the type, so the span only stores a pointer. +// +// Construction: +// +// * Implicitly from `T[Extent]`, `std::array<U, Extent>` and +// `Span<U, Extent>`, where `U*` converts to `T*` by adding qualifiers. +// * Explicitly from a dynamic-extent `Span<U>`, from a pointer and size, and +// from containers that `Span<T>` can be constructed from. The size must +// equal `Extent`, which is checked by Abseil hardening. +// +// A static-extent span converts implicitly to `Span<T>`. There are no +// relational operators between two static-extent spans. +template <typename T, size_t Extent> +class ABSL_ATTRIBUTE_VIEW Span { + private: + // SFINAE-enables a conversion from `U*` to `T*` that only adds qualifiers. + // Unlike `std::is_convertible_v<U*, T*>`, this rejects derived-to-base. + template <typename U> + using EnableIfCompatible = + std::enable_if_t<std::is_convertible_v<U (*)[], T (*)[]>, int>; + + template <typename V> + using RemoveCvRef = std::remove_cv_t<std::remove_reference_t<V>>; + + // SFINAE-enables construction from the containers that `Span<T>` can be + // constructed from, except pointers, arrays and spans. Those have dedicated + // constructors, so that a size mismatch is a compile-time error. + template <typename V> + using EnableIfContainer = + std::enable_if_t<!std::is_pointer_v<RemoveCvRef<V>> && + !std::is_array_v<RemoveCvRef<V>> && + !span_internal::IsStdArray<RemoveCvRef<V>>::value && + !span_internal::IsSpan<RemoveCvRef<V>>::value && + std::is_constructible_v<Span<T>, V>, + int>; + + public: + using element_type = T; + using value_type = std::remove_cv_t<T>; + using pointer = T* absl_nullability_unknown; + using const_pointer = const T* absl_nullability_unknown; + using reference = T&; + using const_reference = const T&; + using iterator = pointer; + using const_iterator = const_pointer; + using reverse_iterator = std::reverse_iterator<iterator>; + using const_reverse_iterator = std::reverse_iterator<const_iterator>; + using size_type = size_t; + using difference_type = ptrdiff_t; + using absl_internal_is_view = std::true_type; + + // NOLINTNEXTLINE + static constexpr size_type npos = static_cast<size_type>(-1); + static constexpr size_type extent = Extent; + + // Only spans of zero elements are default-constructible. + template <size_t E = Extent, std::enable_if_t<E == 0, int> = 0> + constexpr Span() noexcept : ptr_(nullptr) {} + + // Explicit constructor from a pointer and size. `length` must equal `Extent`. + constexpr explicit Span(pointer array ABSL_ATTRIBUTE_LIFETIME_BOUND, + size_type length) noexcept + : ptr_(array) { + absl::base_internal::HardeningAssert(length == Extent); + } + + // Implicit conversion constructors from arrays of exactly `Extent` elements. + constexpr Span( // NOLINT(google-explicit-constructor) + T (&a ABSL_ATTRIBUTE_LIFETIME_BOUND)[Extent]) noexcept + : ptr_(a) {} + + template <typename U, EnableIfCompatible<U> = 0> + constexpr Span( // NOLINT(google-explicit-constructor) + std::array<U, Extent>& a ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept + : ptr_(a.data()) {} + + template <typename U, EnableIfCompatible<const U> = 0> + constexpr Span( // NOLINT(google-explicit-constructor) + const std::array<U, Extent>& a ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept + : ptr_(a.data()) {} + + // Implicit conversion from a span with the same extent, e.g. from + // `Span<int, 4>` to `Span<const int, 4>`. + template <typename U, EnableIfCompatible<U> = 0, + std::enable_if_t<!std::is_same_v<U, T>, int> = 0> + constexpr Span( // NOLINT(google-explicit-constructor) + Span<U, Extent> other) noexcept + : ptr_(other.data()) {} + + // Explicit conversion from a dynamic-extent span. `other.size()` must equal + // `Extent`. + template <typename U, EnableIfCompatible<U> = 0> + constexpr explicit Span(Span<U> other) noexcept + : Span(other.data(), other.size()) {} + + // Explicit conversion from a container. `v.size()` must equal `Extent`. As + // with `Span<T>`, a span of mutable elements needs a mutable container. + template <typename V, EnableIfContainer<V> = 0, + span_internal::EnableIfNotIsView<RemoveCvRef<V>> = 0> + constexpr explicit Span(V&& v ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept + : Span(Span<T>(std::forward<V>(v))) {} + + // Overload of the above for view types, without the lifetime annotation. + template <typename V, EnableIfContainer<V> = 0, + span_internal::EnableIfIsView<RemoveCvRef<V>> = 0> + constexpr explicit Span(V&& v) noexcept : Span(Span<T>(std::forward<V>(v))) {} + + // Accessors. See the dynamic-extent `Span<T>` above for documentation. + + constexpr pointer data() const noexcept { return ptr_; } + constexpr size_type size() const noexcept { return Extent; } + constexpr size_type length() const noexcept { return size(); } + constexpr bool empty() const noexcept { return Extent == 0; } + + constexpr reference operator[](size_type i) const noexcept { + absl::base_internal::HardeningAssertLT(i, size()); + return ptr_[i]; + } + + constexpr reference at(size_type i) const { + return ABSL_PREDICT_TRUE(i < size()) // + ? *(data() + i) + : (ThrowStdOutOfRange("Span::at failed bounds check"), + *(data() + i)); + } + + // Unlike for `Span<T>`, calling `front()` or `back()` on a span of zero + // elements is a compile-time error. + constexpr reference front() const noexcept { + static_assert(Extent > 0, "front() requires a non-empty span"); + return *data(); + } + + constexpr reference back() const noexcept { + static_assert(Extent > 0, "back() requires a non-empty span"); + return *(data() + (Extent - 1)); + } + + constexpr iterator begin() const noexcept { return data(); } + constexpr const_iterator cbegin() const noexcept { return begin(); } + constexpr iterator end() const noexcept { return data() + Extent; } + constexpr const_iterator cend() const noexcept { return end(); } + constexpr reverse_iterator rbegin() const noexcept { + return reverse_iterator(end()); + } + constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); } + constexpr reverse_iterator rend() const noexcept { + return reverse_iterator(begin()); + } + constexpr const_reverse_iterator crend() const noexcept { return rend(); } + + // Span::first<Count>(), Span::last<Count>(), Span::subspan<Offset, Count>() + // + // Static-extent subspans. Out-of-range arguments are compile-time errors. + template <size_t Count> + constexpr Span<T, Count> first() const noexcept { + static_assert(Count <= Extent, "Count must not exceed the extent"); + return Span<T, Count>(data(), Count); + } + + template <size_t Count> + constexpr Span<T, Count> last() const noexcept { + static_assert(Count <= Extent, "Count must not exceed the extent"); + return Span<T, Count>(data() + (Extent - Count), Count); + } + + template <size_t Offset, size_t Count = dynamic_extent> + constexpr auto subspan() const noexcept { + static_assert(Offset <= Extent, "Offset must not exceed the extent"); + static_assert(Count == dynamic_extent || Count <= Extent - Offset, + "Offset + Count must not exceed the extent"); + constexpr size_type kCount = + Count == dynamic_extent ? Extent - Offset : Count; + return Span<T, kCount>(data() + Offset, kCount); + } + + // Span::first(), Span::last(), Span::subspan() + // + // Dynamic-extent subspans, with the same semantics as for `Span<T>`. + constexpr Span<T> first(size_type len) const { + return Span<T>(*this).first(len); + } + + constexpr Span<T> last(size_type len) const { + return Span<T>(*this).last(len); + } + + constexpr Span<T> subspan(size_type pos = 0, size_type len = npos) const { + return Span<T>(*this).subspan(pos, len); + } + + // Support for absl::Hash. Hashes like a `Span<T>` with the same elements. + template <typename H> + friend H AbslHashValue(H h, Span v) { + return H::combine_contiguous(std::move(h), v.data(), v.size()); + } + + private: + pointer ptr_; +}; + +// Class template argument deduction produces dynamic-extent spans, as it did +// before `Span` had an extent parameter. +template <typename T, size_t N> +Span(T (&)[N]) -> Span<T>; + +template <typename T> +Span(T* absl_nullability_unknown, size_t) -> Span<T>; + // Span relationals // Equality is compared element-by-element, while ordering is lexicographical. @@ -523,27 +808,27 @@ // operator== template <typename T> constexpr bool operator==(Span<T> a, Span<T> b) { - return span_internal::EqualImpl<Span, const T>(a, b); + return span_internal::EqualImpl<Span<const T>>(a, b); } template <typename T> constexpr bool operator==(Span<const T> a, Span<T> b) { - return span_internal::EqualImpl<Span, const T>(a, b); + return span_internal::EqualImpl<Span<const T>>(a, b); } template <typename T> constexpr bool operator==(Span<T> a, Span<const T> b) { - return span_internal::EqualImpl<Span, const T>(a, b); + return span_internal::EqualImpl<Span<const T>>(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>> constexpr bool operator==(const U& a, Span<T> b) { - return span_internal::EqualImpl<Span, const T>(a, b); + return span_internal::EqualImpl<Span<const T>>(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>> constexpr bool operator==(Span<T> a, const U& b) { - return span_internal::EqualImpl<Span, const T>(a, b); + return span_internal::EqualImpl<Span<const T>>(a, b); } // operator!= @@ -575,27 +860,27 @@ // operator< template <typename T> constexpr bool operator<(Span<T> a, Span<T> b) { - return span_internal::LessThanImpl<Span, const T>(a, b); + return span_internal::LessThanImpl<Span<const T>>(a, b); } template <typename T> constexpr bool operator<(Span<const T> a, Span<T> b) { - return span_internal::LessThanImpl<Span, const T>(a, b); + return span_internal::LessThanImpl<Span<const T>>(a, b); } template <typename T> constexpr bool operator<(Span<T> a, Span<const T> b) { - return span_internal::LessThanImpl<Span, const T>(a, b); + return span_internal::LessThanImpl<Span<const T>>(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>> constexpr bool operator<(const U& a, Span<T> b) { - return span_internal::LessThanImpl<Span, const T>(a, b); + return span_internal::LessThanImpl<Span<const T>>(a, b); } template < typename T, typename U, typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>> constexpr bool operator<(Span<T> a, const U& b) { - return span_internal::LessThanImpl<Span, const T>(a, b); + return span_internal::LessThanImpl<Span<const T>>(a, b); } // operator>
diff --git a/absl/types/span_test.cc b/absl/types/span_test.cc index 57cbb99..28b3758 100644 --- a/absl/types/span_test.cc +++ b/absl/types/span_test.cc
@@ -908,4 +908,251 @@ absl::HashOf(absl::FixedArray<int>{1, 2, 3})); } +// Static extents. + +using S4 = absl::Span<int, 4>; +using CS4 = absl::Span<const int, 4>; + +static_assert( + std::is_same_v<absl::Span<int>, absl::Span<int, absl::dynamic_extent>>); +static_assert(absl::Span<int>::extent == absl::dynamic_extent); +static_assert(S4::extent == 4); +static_assert(sizeof(S4) == sizeof(int*), "only the pointer is stored"); +static_assert(!absl::type_traits_internal::IsOwner<S4>::value && + absl::type_traits_internal::IsView<S4>::value, + "Span is a view, not an owner"); +static_assert(std::is_trivially_destructible_v<S4> && + std::is_trivially_copyable_v<S4> && + std::is_trivially_copy_assignable_v<S4> && + std::is_trivially_copy_constructible_v<S4>, + "Span<T, N> should be trivial in everything except construction"); +static_assert(!std::is_default_constructible_v<S4>); +static_assert(std::is_default_constructible_v<absl::Span<int, 0>>); + +// Conversions that keep the size are implicit. +static_assert(std::is_convertible_v<int (&)[4], S4>); +static_assert(std::is_convertible_v<std::array<int, 4>&, S4>); +static_assert(std::is_convertible_v<const std::array<int, 4>&, CS4>); +static_assert(std::is_convertible_v<S4, CS4>); +static_assert(std::is_convertible_v<S4, absl::Span<int>>); +static_assert(std::is_convertible_v<S4, absl::Span<const int>>); + +// Conversions that may change the size are explicit. +static_assert(!std::is_convertible_v<absl::Span<int>, S4>); +static_assert(std::is_constructible_v<S4, absl::Span<int>>); +static_assert(!std::is_convertible_v<std::vector<int>&, S4>); +static_assert(std::is_constructible_v<S4, std::vector<int>&>); +static_assert(std::is_constructible_v<CS4, const std::vector<int>&>); +static_assert(std::is_constructible_v<S4, int*, size_t>); + +// Size mismatches known at compile time are compile errors. +static_assert(!std::is_constructible_v<S4, int (&)[3]>); +static_assert(!std::is_constructible_v<S4, std::array<int, 3>&>); +static_assert(!std::is_constructible_v<S4, absl::Span<int, 3>>); + +// Constness and derived-to-base conversions are rejected. +static_assert(!std::is_constructible_v<S4, const std::array<int, 4>&>); +static_assert(!std::is_constructible_v<S4, CS4>); +static_assert(!std::is_constructible_v<S4, const std::vector<int>&>); +static_assert(!std::is_constructible_v<S4, std::vector<int>&&>); +// `Base` and `Derived` are defined above. +static_assert(!std::is_constructible_v<absl::Span<Base, 2>, Derived (&)[2]>); +static_assert( + !std::is_constructible_v<absl::Span<Base, 2>, absl::Span<Derived, 2>>); + +#if defined(__cpp_lib_ranges) && __cpp_lib_ranges >= 201911L +static_assert(std::ranges::borrowed_range<S4>); // NOLINT(build/c++20) +static_assert(std::ranges::view<S4>); // NOLINT(build/c++20) +#endif + +TEST(StaticSpan, DeductionGuidesKeepDynamicExtent) { + int a[4] = {}; + const int ca[3] = {}; + absl::Span s1(a); + absl::Span s2(ca); + absl::Span s3(a, 2); + static_assert(std::is_same_v<decltype(s1), absl::Span<int>>); + static_assert(std::is_same_v<decltype(s2), absl::Span<const int>>); + static_assert(std::is_same_v<decltype(s3), absl::Span<int>>); + EXPECT_EQ(s1.size(), 4); + EXPECT_EQ(s2.size(), 3); + EXPECT_EQ(s3.size(), 2); +} + +TEST(StaticSpan, FromArray) { + int a[4] = {1, 2, 3, 4}; + S4 s = a; + EXPECT_EQ(s.data(), a); + EXPECT_EQ(s.size(), 4); + EXPECT_FALSE(s.empty()); + EXPECT_EQ(s.front(), 1); + EXPECT_EQ(s.back(), 4); + EXPECT_EQ(s[2], 3); + EXPECT_EQ(s.at(3), 4); + EXPECT_THAT(s, testing::ElementsAre(1, 2, 3, 4)); + ABSL_BASE_INTERNAL_EXPECT_FAIL(s.at(4), std::out_of_range, + "failed bounds check"); +} + +TEST(StaticSpan, FromStdArray) { + std::array<int, 3> a = {1, 2, 3}; + absl::Span<int, 3> s = a; + absl::Span<const int, 3> cs = a; + const std::array<int, 3>& ca = a; + absl::Span<const int, 3> ccs = ca; + EXPECT_EQ(s.data(), a.data()); + EXPECT_EQ(cs.data(), a.data()); + EXPECT_EQ(ccs.data(), a.data()); +} + +TEST(StaticSpan, ToDynamic) { + int a[4] = {1, 2, 3, 4}; + S4 s = a; + absl::Span<int> d = s; + absl::Span<const int> cd = s; + absl::Span<int> direct(s); + EXPECT_EQ(d.data(), a); + EXPECT_EQ(d.size(), 4); + EXPECT_EQ(cd.data(), a); + EXPECT_EQ(cd.size(), 4); + EXPECT_EQ(direct.size(), 4); +} + +TEST(StaticSpan, FromDynamicAndContainers) { + std::vector<int> v = {1, 2, 3, 4}; + S4 from_span(absl::MakeSpan(v)); + S4 from_vector(v); + CS4 from_const_vector(static_cast<const std::vector<int>&>(v)); + S4 from_pointer(v.data(), v.size()); + EXPECT_EQ(from_span.data(), v.data()); + EXPECT_EQ(from_vector.data(), v.data()); + EXPECT_EQ(from_const_vector.data(), v.data()); + EXPECT_EQ(from_pointer.data(), v.data()); + + std::string str = "abc"; + absl::Span<char, 3> chars(str); + EXPECT_EQ(chars.data(), str.data()); +} + +#if !defined(NDEBUG) || ABSL_OPTION_HARDENED +TEST(StaticSpan, SizeMismatchDies) { + std::vector<int> v = {1, 2, 3}; + EXPECT_DEATH_IF_SUPPORTED( + { + S4 s(absl::MakeSpan(v)); + (void)s; + }, + ""); + EXPECT_DEATH_IF_SUPPORTED( + { + S4 s(v); + (void)s; + }, + ""); + EXPECT_DEATH_IF_SUPPORTED( + { + S4 s(v.data(), v.size()); + (void)s; + }, + ""); +} + +TEST(StaticSpan, ElementAccessDies) { + int a[4] = {1, 2, 3, 4}; + S4 s = a; + EXPECT_DEATH_IF_SUPPORTED(s[4], ""); +} +#endif + +TEST(StaticSpan, StaticSubspans) { + int a[5] = {0, 1, 2, 3, 4}; + absl::Span<int, 5> s = a; + + auto first = s.first<2>(); + auto last = s.last<2>(); + auto middle = s.subspan<1, 3>(); + auto rest = s.subspan<2>(); + auto none = s.subspan<5>(); + static_assert(std::is_same_v<decltype(first), absl::Span<int, 2>>); + static_assert(std::is_same_v<decltype(last), absl::Span<int, 2>>); + static_assert(std::is_same_v<decltype(middle), absl::Span<int, 3>>); + static_assert(std::is_same_v<decltype(rest), absl::Span<int, 3>>); + static_assert(std::is_same_v<decltype(none), absl::Span<int, 0>>); + EXPECT_THAT(first, testing::ElementsAre(0, 1)); + EXPECT_THAT(last, testing::ElementsAre(3, 4)); + EXPECT_THAT(middle, testing::ElementsAre(1, 2, 3)); + EXPECT_THAT(rest, testing::ElementsAre(2, 3, 4)); + EXPECT_TRUE(none.empty()); +} + +TEST(StaticSpan, DynamicSubspansOfStaticSpan) { + int a[5] = {0, 1, 2, 3, 4}; + absl::Span<int, 5> s = a; + + auto first = s.first(2); + static_assert(std::is_same_v<decltype(first), absl::Span<int>>); + EXPECT_THAT(first, testing::ElementsAre(0, 1)); + EXPECT_THAT(s.last(1), testing::ElementsAre(4)); + // Truncates like `Span<T>::subspan()`. + EXPECT_THAT(s.subspan(3, 10), testing::ElementsAre(3, 4)); + ABSL_BASE_INTERNAL_EXPECT_FAIL(s.subspan(6), std::out_of_range, + "pos > size()"); +} + +TEST(StaticSpan, StaticSubspansOfDynamicSpan) { + std::vector<int> v = {0, 1, 2, 3, 4}; + absl::Span<int> d = absl::MakeSpan(v); + + auto first = d.first<2>(); + auto last = d.last<3>(); + auto middle = d.subspan<1, 2>(); + auto rest = d.subspan<1>(); + static_assert(std::is_same_v<decltype(first), absl::Span<int, 2>>); + static_assert(std::is_same_v<decltype(last), absl::Span<int, 3>>); + static_assert(std::is_same_v<decltype(middle), absl::Span<int, 2>>); + static_assert(std::is_same_v<decltype(rest), absl::Span<int>>); + EXPECT_THAT(first, testing::ElementsAre(0, 1)); + EXPECT_THAT(last, testing::ElementsAre(2, 3, 4)); + EXPECT_THAT(middle, testing::ElementsAre(1, 2)); + EXPECT_THAT(rest, testing::ElementsAre(1, 2, 3, 4)); + + // Unlike `subspan(pos, len)`, the static versions never truncate. + ABSL_BASE_INTERNAL_EXPECT_FAIL(d.first<6>(), std::out_of_range, + "len > size()"); + ABSL_BASE_INTERNAL_EXPECT_FAIL((d.subspan<4, 2>()), std::out_of_range, + "len > size()"); + ABSL_BASE_INTERNAL_EXPECT_FAIL(d.subspan<6>(), std::out_of_range, + "pos > size()"); +} + +TEST(StaticSpan, Constexpr) { + static constexpr int kArray[3] = {1, 2, 3}; + constexpr absl::Span<const int, 3> s = kArray; + constexpr absl::Span<const int> d = s; + static_assert(s.size() == 3); + static_assert(s[1] == 2); + static_assert(s.first<2>().back() == 2); + static_assert(s.subspan<1>().front() == 2); + static_assert(d.size() == 3); + static_assert(d.last<1>().front() == 3); +} + +TEST(StaticSpan, IterationAndHash) { + int a[3] = {1, 2, 3}; + absl::Span<const int, 3> s = a; + EXPECT_EQ(std::accumulate(s.begin(), s.end(), 0), 6); + EXPECT_THAT(std::vector<int>(s.rbegin(), s.rend()), + testing::ElementsAre(3, 2, 1)); + EXPECT_EQ(absl::HashOf(s), absl::HashOf(absl::Span<const int>(a))); +} + +TEST(StaticSpan, ComparesWithDynamicSpans) { + int a[3] = {1, 2, 3}; + std::vector<int> v = {1, 2, 3}; + absl::Span<const int, 3> s = a; + EXPECT_TRUE(s == absl::MakeConstSpan(v)); + EXPECT_TRUE(absl::MakeConstSpan(v) == s); + EXPECT_FALSE(s < absl::MakeConstSpan(v)); +} + } // namespace