libcxx/include/span

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===---------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP_SPAN
  11 #define _LIBCPP_SPAN
  12
  13 /*
  14     span synopsis
  15
  16 namespace std {
  17
  18 // constants
  19 inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
  20
  21 // [views.span], class template span
  22 template <class ElementType, size_t Extent = dynamic_extent>
  23     class span;
  24
  25 template<class ElementType, size_t Extent>
  26   inline constexpr bool ranges::enable_view<span<ElementType, Extent>> = true;
  27
  28 template<class ElementType, size_t Extent>
  29     inline constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true;
  30
  31 // [span.objectrep], views of object representation
  32 template <class ElementType, size_t Extent>
  33     span<const byte, ((Extent == dynamic_extent) ? dynamic_extent :
  34         (sizeof(ElementType) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;
  35
  36 template <class ElementType, size_t Extent>
  37     span<      byte, ((Extent == dynamic_extent) ? dynamic_extent :
  38         (sizeof(ElementType) * Extent))> as_writable_bytes(span<ElementType, Extent> s) noexcept;
  39
  40
  41 template <class ElementType, size_t Extent = dynamic_extent>
  42 class span {
  43 public:
  44     // constants and types
  45     using element_type = ElementType;
  46     using value_type = remove_cv_t<ElementType>;
  47     using size_type = size_t;
  48     using difference_type = ptrdiff_t;
  49     using pointer = element_type*;
  50     using const_pointer = const element_type*;
  51     using reference = element_type&;
  52     using const_reference = const element_type&;
  53     using iterator = implementation-defined;
  54     using reverse_iterator = std::reverse_iterator<iterator>;
  55     static constexpr size_type extent = Extent;
  56
  57     // [span.cons], span constructors, copy, assignment, and destructor
  58     constexpr span() noexcept;
  59     template <class It>
  60     constexpr explicit(Extent != dynamic_extent) span(It first, size_type count);
  61     template <class It, class End>
  62     constexpr explicit(Extent != dynamic_extent) span(It first, End last);
  63     template <size_t N>
  64         constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
  65     template <size_t N>
  66         constexpr span(array<value_type, N>& arr) noexcept;
  67     template <size_t N>
  68         constexpr span(const array<value_type, N>& arr) noexcept;
  69     template<class R>
  70       constexpr explicit(Extent != dynamic_extent) span(R&& r);
  71     constexpr span(const span& other) noexcept = default;
  72     template <class OtherElementType, size_t OtherExtent>
  73         constexpr explicit(Extent != dynamic_extent) span(const span<OtherElementType, OtherExtent>& s) noexcept;
  74     constexpr span& operator=(const span& other) noexcept = default;
  75
  76     // [span.sub], span subviews
  77     template <size_t Count>
  78         constexpr span<element_type, Count> first() const;
  79     template <size_t Count>
  80         constexpr span<element_type, Count> last() const;
  81     template <size_t Offset, size_t Count = dynamic_extent>
  82         constexpr span<element_type, see below> subspan() const;
  83
  84     constexpr span<element_type, dynamic_extent> first(size_type count) const;
  85     constexpr span<element_type, dynamic_extent> last(size_type count) const;
  86     constexpr span<element_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const;
  87
  88     // [span.obs], span observers
  89     constexpr size_type size() const noexcept;
  90     constexpr size_type size_bytes() const noexcept;
  91     [[nodiscard]] constexpr bool empty() const noexcept;
  92
  93     // [span.elem], span element access
  94     constexpr reference operator[](size_type idx) const;
  95     constexpr reference front() const;
  96     constexpr reference back() const;
  97     constexpr pointer data() const noexcept;
  98
  99     // [span.iterators], span iterator support
 100     constexpr iterator begin() const noexcept;
 101     constexpr iterator end() const noexcept;
 102     constexpr reverse_iterator rbegin() const noexcept;
 103     constexpr reverse_iterator rend() const noexcept;
 104
 105 private:
 106     pointer data_;    // exposition only
 107     size_type size_;  // exposition only
 108 };
 109
 110 template<class It, class EndOrSize>
 111     span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
 112
 113 template<class T, size_t N>
 114     span(T (&)[N]) -> span<T, N>;
 115
 116 template<class T, size_t N>
 117     span(array<T, N>&) -> span<T, N>;
 118
 119 template<class T, size_t N>
 120     span(const array<T, N>&) -> span<const T, N>;
 121
 122 template<class R>
 123     span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
 124
 125 } // namespace std
 126
 127 */
 128
 129 #include <__assert> // all public C++ headers provide the assertion handler
 130 #include <__config>
 131 #include <__fwd/span.h>
 132 #include <__iterator/bounded_iter.h>
 133 #include <__iterator/concepts.h>
 134 #include <__iterator/iterator_traits.h>
 135 #include <__iterator/wrap_iter.h>
 136 #include <__memory/pointer_traits.h>
 137 #include <__ranges/concepts.h>
 138 #include <__ranges/data.h>
 139 #include <__ranges/enable_borrowed_range.h>
 140 #include <__ranges/enable_view.h>
 141 #include <__ranges/size.h>
 142 #include <__type_traits/is_convertible.h>
 143 #include <__type_traits/remove_cvref.h>
 144 #include <__type_traits/remove_reference.h>
 145 #include <__type_traits/type_identity.h>
 146 #include <__utility/forward.h>
 147 #include <array>   // for array
 148 #include <cstddef> // for byte
 149 #include <version>
 150
 151 // standard-mandated includes
 152
 153 // [iterator.range]
 154 #include <__iterator/access.h>
 155 #include <__iterator/data.h>
 156 #include <__iterator/empty.h>
 157 #include <__iterator/reverse_access.h>
 158 #include <__iterator/size.h>
 159
 160 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 161 #  pragma GCC system_header
 162 #endif
 163
 164 _LIBCPP_PUSH_MACROS
 165 #include <__undef_macros>
 166
 167 _LIBCPP_BEGIN_NAMESPACE_STD
 168
 169 #if _LIBCPP_STD_VER >= 20
 170
 171 template <class _Tp>
 172 struct __is_std_array : false_type {};
 173
 174 template <class _Tp, size_t _Sz>
 175 struct __is_std_array<array<_Tp, _Sz>> : true_type {};
 176
 177 template <class _Tp>
 178 struct __is_std_span : false_type {};
 179
 180 template <class _Tp, size_t _Sz>
 181 struct __is_std_span<span<_Tp, _Sz>> : true_type {};
 182
 183 template <class _Range, class _ElementType>
 184 concept __span_compatible_range =
 185     ranges::contiguous_range<_Range> &&                            //
 186     ranges::sized_range<_Range> &&                                 //
 187     (ranges::borrowed_range<_Range> || is_const_v<_ElementType>)&& //
 188     !__is_std_span<remove_cvref_t<_Range>>::value &&               //
 189     !__is_std_array<remove_cvref_t<_Range>>::value &&              //
 190     !is_array_v<remove_cvref_t<_Range>> &&                         //
 191     is_convertible_v<remove_reference_t<ranges::range_reference_t<_Range>> (*)[], _ElementType (*)[]>;
 192
 193 template <class _From, class _To>
 194 concept __span_array_convertible = is_convertible_v<_From (*)[], _To (*)[]>;
 195
 196 template <class _It, class _Tp>
 197 concept __span_compatible_iterator =
 198     contiguous_iterator<_It> && __span_array_convertible<remove_reference_t<iter_reference_t<_It>>, _Tp>;
 199
 200 template <class _Sentinel, class _It>
 201 concept __span_compatible_sentinel_for = sized_sentinel_for<_Sentinel, _It> && !is_convertible_v<_Sentinel, size_t>;
 202
 203 template <typename _Tp, size_t _Extent>
 204 class _LIBCPP_TEMPLATE_VIS span {
 205 public:
 206   //  constants and types
 207   using element_type    = _Tp;
 208   using value_type      = remove_cv_t<_Tp>;
 209   using size_type       = size_t;
 210   using difference_type = ptrdiff_t;
 211   using pointer         = _Tp*;
 212   using const_pointer   = const _Tp*;
 213   using reference       = _Tp&;
 214   using const_reference = const _Tp&;
 215 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 216   using iterator = __bounded_iter<pointer>;
 217 #  else
 218   using iterator = __wrap_iter<pointer>;
 219 #  endif
 220   using reverse_iterator = std::reverse_iterator<iterator>;
 221
 222   static constexpr size_type extent = _Extent;
 223
 224   // [span.cons], span constructors, copy, assignment, and destructor
 225   template <size_t _Sz = _Extent>
 226     requires(_Sz == 0)
 227   _LIBCPP_HIDE_FROM_ABI constexpr span() noexcept : __data_{nullptr} {}
 228
 229   constexpr span(const span&) noexcept            = default;
 230   constexpr span& operator=(const span&) noexcept = default;
 231
 232   template <__span_compatible_iterator<element_type> _It>
 233   _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_It __first, size_type __count) : __data_{std::to_address(__first)} {
 234     (void)__count;
 235     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Extent == __count, "size mismatch in span's constructor (iterator, len)");
 236   }
 237
 238   template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
 239   _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_It __first, _End __last) : __data_{std::to_address(__first)} {
 240     // [span.cons]/10
 241     // Throws: When and what last - first throws.
 242     [[maybe_unused]] auto __dist = __last - __first;
 243     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__dist >= 0, "invalid range in span's constructor (iterator, sentinel)");
 244     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
 245         __dist == _Extent, "invalid range in span's constructor (iterator, sentinel): last - first != extent");
 246   }
 247
 248   _LIBCPP_HIDE_FROM_ABI constexpr span(type_identity_t<element_type> (&__arr)[_Extent]) noexcept : __data_{__arr} {}
 249
 250   template <__span_array_convertible<element_type> _OtherElementType>
 251   _LIBCPP_HIDE_FROM_ABI constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data_{__arr.data()} {}
 252
 253   template <class _OtherElementType>
 254     requires __span_array_convertible<const _OtherElementType, element_type>
 255   _LIBCPP_HIDE_FROM_ABI constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept
 256       : __data_{__arr.data()} {}
 257
 258   template <__span_compatible_range<element_type> _Range>
 259   _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_Range&& __r) : __data_{ranges::data(__r)} {
 260     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)");
 261   }
 262
 263   template <__span_array_convertible<element_type> _OtherElementType>
 264   _LIBCPP_HIDE_FROM_ABI constexpr span(const span<_OtherElementType, _Extent>& __other) : __data_{__other.data()} {}
 265
 266   template <__span_array_convertible<element_type> _OtherElementType>
 267   _LIBCPP_HIDE_FROM_ABI constexpr explicit span(const span<_OtherElementType, dynamic_extent>& __other) noexcept
 268       : __data_{__other.data()} {
 269     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Extent == __other.size(), "size mismatch in span's constructor (other span)");
 270   }
 271
 272   template <size_t _Count>
 273   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
 274     static_assert(_Count <= _Extent, "span<T, N>::first<Count>(): Count out of range");
 275     return span<element_type, _Count>{data(), _Count};
 276   }
 277
 278   template <size_t _Count>
 279   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
 280     static_assert(_Count <= _Extent, "span<T, N>::last<Count>(): Count out of range");
 281     return span<element_type, _Count>{data() + size() - _Count, _Count};
 282   }
 283
 284   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
 285     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::first(count): count out of range");
 286     return {data(), __count};
 287   }
 288
 289   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
 290     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::last(count): count out of range");
 291     return {data() + size() - __count, __count};
 292   }
 293
 294   template <size_t _Offset, size_t _Count = dynamic_extent>
 295   _LIBCPP_HIDE_FROM_ABI constexpr auto subspan() const noexcept
 296       -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset> {
 297     static_assert(_Offset <= _Extent, "span<T, N>::subspan<Offset, Count>(): Offset out of range");
 298     static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset,
 299                   "span<T, N>::subspan<Offset, Count>(): Offset + Count out of range");
 300
 301     using _ReturnType = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
 302     return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
 303   }
 304
 305   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
 306   subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
 307     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T, N>::subspan(offset, count): offset out of range");
 308     if (__count == dynamic_extent)
 309       return {data() + __offset, size() - __offset};
 310     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
 311         __count <= size() - __offset, "span<T, N>::subspan(offset, count): offset + count out of range");
 312     return {data() + __offset, __count};
 313   }
 314
 315   _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return _Extent; }
 316   _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
 317   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return _Extent == 0; }
 318
 319   _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
 320     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T, N>::operator[](index): index out of range");
 321     return __data_[__idx];
 322   }
 323
 324   _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
 325     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::front() on empty span");
 326     return __data_[0];
 327   }
 328
 329   _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
 330     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::back() on empty span");
 331     return __data_[size() - 1];
 332   }
 333
 334   _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
 335
 336   // [span.iter], span iterator support
 337   _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
 338 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 339     return std::__make_bounded_iter(data(), data(), data() + size());
 340 #  else
 341     return iterator(data());
 342 #  endif
 343   }
 344   _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
 345 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 346     return std::__make_bounded_iter(data() + size(), data(), data() + size());
 347 #  else
 348     return iterator(data() + size());
 349 #  endif
 350   }
 351   _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
 352   _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
 353
 354   _LIBCPP_HIDE_FROM_ABI span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept {
 355     return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte*>(data()), size_bytes()};
 356   }
 357
 358   _LIBCPP_HIDE_FROM_ABI span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept {
 359     return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte*>(data()), size_bytes()};
 360   }
 361
 362 private:
 363   pointer __data_;
 364 };
 365
 366 template <typename _Tp>
 367 class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> {
 368 public:
 369   //  constants and types
 370   using element_type    = _Tp;
 371   using value_type      = remove_cv_t<_Tp>;
 372   using size_type       = size_t;
 373   using difference_type = ptrdiff_t;
 374   using pointer         = _Tp*;
 375   using const_pointer   = const _Tp*;
 376   using reference       = _Tp&;
 377   using const_reference = const _Tp&;
 378 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 379   using iterator = __bounded_iter<pointer>;
 380 #  else
 381   using iterator = __wrap_iter<pointer>;
 382 #  endif
 383   using reverse_iterator = std::reverse_iterator<iterator>;
 384
 385   static constexpr size_type extent = dynamic_extent;
 386
 387   // [span.cons], span constructors, copy, assignment, and destructor
 388   _LIBCPP_HIDE_FROM_ABI constexpr span() noexcept : __data_{nullptr}, __size_{0} {}
 389
 390   constexpr span(const span&) noexcept            = default;
 391   constexpr span& operator=(const span&) noexcept = default;
 392
 393   template <__span_compatible_iterator<element_type> _It>
 394   _LIBCPP_HIDE_FROM_ABI constexpr span(_It __first, size_type __count)
 395       : __data_{std::to_address(__first)}, __size_{__count} {}
 396
 397   template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
 398   _LIBCPP_HIDE_FROM_ABI constexpr span(_It __first, _End __last)
 399       : __data_(std::to_address(__first)), __size_(__last - __first) {
 400     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__last - __first >= 0, "invalid range in span's constructor (iterator, sentinel)");
 401   }
 402
 403   template <size_t _Sz>
 404   _LIBCPP_HIDE_FROM_ABI constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept
 405       : __data_{__arr}, __size_{_Sz} {}
 406
 407   template <__span_array_convertible<element_type> _OtherElementType, size_t _Sz>
 408   _LIBCPP_HIDE_FROM_ABI constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept
 409       : __data_{__arr.data()}, __size_{_Sz} {}
 410
 411   template <class _OtherElementType, size_t _Sz>
 412     requires __span_array_convertible<const _OtherElementType, element_type>
 413   _LIBCPP_HIDE_FROM_ABI constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept
 414       : __data_{__arr.data()}, __size_{_Sz} {}
 415
 416   template <__span_compatible_range<element_type> _Range>
 417   _LIBCPP_HIDE_FROM_ABI constexpr span(_Range&& __r) : __data_(ranges::data(__r)), __size_{ranges::size(__r)} {}
 418
 419   template <__span_array_convertible<element_type> _OtherElementType, size_t _OtherExtent>
 420   _LIBCPP_HIDE_FROM_ABI constexpr span(const span<_OtherElementType, _OtherExtent>& __other) noexcept
 421       : __data_{__other.data()}, __size_{__other.size()} {}
 422
 423   template <size_t _Count>
 424   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
 425     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::first<Count>(): Count out of range");
 426     return span<element_type, _Count>{data(), _Count};
 427   }
 428
 429   template <size_t _Count>
 430   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
 431     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::last<Count>(): Count out of range");
 432     return span<element_type, _Count>{data() + size() - _Count, _Count};
 433   }
 434
 435   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
 436     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::first(count): count out of range");
 437     return {data(), __count};
 438   }
 439
 440   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
 441     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::last(count): count out of range");
 442     return {data() + size() - __count, __count};
 443   }
 444
 445   template <size_t _Offset, size_t _Count = dynamic_extent>
 446   _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> subspan() const noexcept {
 447     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Offset <= size(), "span<T>::subspan<Offset, Count>(): Offset out of range");
 448     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count == dynamic_extent || _Count <= size() - _Offset,
 449                                         "span<T>::subspan<Offset, Count>(): Offset + Count out of range");
 450     return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
 451   }
 452
 453   constexpr span<element_type, dynamic_extent> _LIBCPP_HIDE_FROM_ABI
 454   subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
 455     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T>::subspan(offset, count): offset out of range");
 456     if (__count == dynamic_extent)
 457       return {data() + __offset, size() - __offset};
 458     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
 459         __count <= size() - __offset, "span<T>::subspan(offset, count): offset + count out of range");
 460     return {data() + __offset, __count};
 461   }
 462
 463   _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return __size_; }
 464   _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return __size_ * sizeof(element_type); }
 465   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return __size_ == 0; }
 466
 467   _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
 468     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T>::operator[](index): index out of range");
 469     return __data_[__idx];
 470   }
 471
 472   _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
 473     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::front() on empty span");
 474     return __data_[0];
 475   }
 476
 477   _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
 478     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::back() on empty span");
 479     return __data_[size() - 1];
 480   }
 481
 482   _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
 483
 484   // [span.iter], span iterator support
 485   _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
 486 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 487     return std::__make_bounded_iter(data(), data(), data() + size());
 488 #  else
 489     return iterator(data());
 490 #  endif
 491   }
 492   _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
 493 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
 494     return std::__make_bounded_iter(data() + size(), data(), data() + size());
 495 #  else
 496     return iterator(data() + size());
 497 #  endif
 498   }
 499   _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
 500   _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
 501
 502   _LIBCPP_HIDE_FROM_ABI span<const byte, dynamic_extent> __as_bytes() const noexcept {
 503     return {reinterpret_cast<const byte*>(data()), size_bytes()};
 504   }
 505
 506   _LIBCPP_HIDE_FROM_ABI span<byte, dynamic_extent> __as_writable_bytes() const noexcept {
 507     return {reinterpret_cast<byte*>(data()), size_bytes()};
 508   }
 509
 510 private:
 511   pointer __data_;
 512   size_type __size_;
 513 };
 514
 515 template <class _Tp, size_t _Extent>
 516 inline constexpr bool ranges::enable_borrowed_range<span<_Tp, _Extent> > = true;
 517
 518 template <class _ElementType, size_t _Extent>
 519 inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
 520
 521 //  as_bytes & as_writable_bytes
 522 template <class _Tp, size_t _Extent>
 523 _LIBCPP_HIDE_FROM_ABI auto as_bytes(span<_Tp, _Extent> __s) noexcept {
 524   return __s.__as_bytes();
 525 }
 526
 527 template <class _Tp, size_t _Extent>
 528   requires(!is_const_v<_Tp>)
 529 _LIBCPP_HIDE_FROM_ABI auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept {
 530   return __s.__as_writable_bytes();
 531 }
 532
 533 #  if _LIBCPP_STD_VER >= 20
 534 template <contiguous_iterator _It, class _EndOrSize>
 535 span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
 536 #  endif // _LIBCPP_STD_VER >= 20
 537
 538 template <class _Tp, size_t _Sz>
 539 span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
 540
 541 template <class _Tp, size_t _Sz>
 542 span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
 543
 544 template <class _Tp, size_t _Sz>
 545 span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
 546
 547 template <ranges::contiguous_range _Range>
 548 span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>;
 549
 550 #endif // _LIBCPP_STD_VER >= 20
 551
 552 _LIBCPP_END_NAMESPACE_STD
 553
 554 _LIBCPP_POP_MACROS
 555
 556 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 557 #  include <concepts>
 558 #  include <functional>
 559 #  include <iterator>
 560 #  include <type_traits>
 561 #endif
 562
 563 #endif // _LIBCPP_SPAN