span 24 KB

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