codekingpro/portable-devtools
114k
1// -*- C++ -*-2//===------------------------------ span ---------------------------------===//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-exception7// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.8//9//===---------------------------------------------------------------------===//10 11#ifndef _LIBCUDACXX_SPAN12#define _LIBCUDACXX_SPAN13 14/*15 span synopsis16 17namespace std {18 19// constants20inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();21 22// [views.span], class template span23template <class ElementType, size_t Extent = dynamic_extent>24 class span;25 26template<class ElementType, size_t Extent>27 inline constexpr bool ranges::enable_view<span<ElementType, Extent>> = true;28 29template<class ElementType, size_t Extent>30 inline constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true;31 32// [span.objectrep], views of object representation33template <class ElementType, size_t Extent>34 span<const byte, ((Extent == dynamic_extent) ? dynamic_extent :35 (sizeof(ElementType) * Extent))> as_bytes(span<ElementType, Extent> s) noexcept;36 37template <class ElementType, size_t Extent>38 span< byte, ((Extent == dynamic_extent) ? dynamic_extent :39 (sizeof(ElementType) * Extent))> as_writable_bytes(span<ElementType, Extent> s) noexcept;40 41 42template <class ElementType, size_t Extent = dynamic_extent>43class span {44public:45 // constants and types46 using element_type = ElementType;47 using value_type = remove_cv_t<ElementType>;48 using size_type = size_t;49 using difference_type = ptrdiff_t;50 using pointer = element_type*;51 using const_pointer = const element_type*;52 using reference = element_type&;53 using const_reference = const element_type&;54 using iterator = implementation-defined;55 using reverse_iterator = std::reverse_iterator<iterator>;56 static constexpr size_type extent = Extent;57 58 // [span.cons], span constructors, copy, assignment, and destructor59 constexpr span() noexcept;60 template <class It>61 constexpr explicit(Extent != dynamic_extent) span(It first, size_type count);62 template <class It, class End>63 constexpr explicit(Extent != dynamic_extent) span(It first, End last);64 template <size_t N>65 constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;66 template <size_t N>67 constexpr span(array<value_type, N>& arr) noexcept;68 template <size_t N>69 constexpr span(const array<value_type, N>& arr) noexcept;70 template<class R>71 constexpr explicit(Extent != dynamic_extent) span(R&& r);72 constexpr span(const span& other) noexcept = default;73 template <class OtherElementType, size_t OtherExtent>74 constexpr explicit(Extent != dynamic_extent) span(const span<OtherElementType, OtherExtent>& s) noexcept;75 ~span() noexcept = default;76 constexpr span& operator=(const span& other) noexcept = default;77 78 // [span.sub], span subviews79 template <size_t Count>80 constexpr span<element_type, Count> first() const;81 template <size_t Count>82 constexpr span<element_type, Count> last() const;83 template <size_t Offset, size_t Count = dynamic_extent>84 constexpr span<element_type, see below> subspan() const;85 86 constexpr span<element_type, dynamic_extent> first(size_type count) const;87 constexpr span<element_type, dynamic_extent> last(size_type count) const;88 constexpr span<element_type, dynamic_extent> subspan(size_type offset, size_type count = dynamic_extent) const;89 90 // [span.obs], span observers91 constexpr size_type size() const noexcept;92 constexpr size_type size_bytes() const noexcept;93 [[nodiscard]] constexpr bool empty() const noexcept;94 95 // [span.elem], span element access96 constexpr reference operator[](size_type idx) const;97 constexpr reference front() const;98 constexpr reference back() const;99 constexpr pointer data() const noexcept;100 101 // [span.iterators], span iterator support102 constexpr iterator begin() const noexcept;103 constexpr iterator end() const noexcept;104 constexpr reverse_iterator rbegin() const noexcept;105 constexpr reverse_iterator rend() const noexcept;106 107private:108 pointer data_; // exposition only109 size_type size_; // exposition only110};111 112template<class It, class EndOrSize>113 span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;114 115template<class T, size_t N>116 span(T (&)[N]) -> span<T, N>;117 118template<class T, size_t N>119 span(array<T, N>&) -> span<T, N>;120 121template<class T, size_t N>122 span(const array<T, N>&) -> span<const T, N>;123 124template<class R>125 span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;126 127} // namespace std128 129*/130 131#ifndef __cuda_std__132#include <__config>133#endif // __cuda_std__134 135#include "__assert" // all public C++ headers provide the assertion handler136#include "__fwd/array.h"137#include "__fwd/span.h"138#include "__fwd/string.h"139#include "__iterator/data.h"140#include "__iterator/distance.h"141#include "__iterator/size.h"142#include "__iterator/iterator_traits.h"143#include "__iterator/reverse_iterator.h"144#include "__iterator/wrap_iter.h"145#include "__memory/pointer_traits.h"146#include "__type_traits/enable_if.h"147#include "__type_traits/integral_constant.h"148#include "__type_traits/is_array.h"149#include "__type_traits/is_const.h"150#include "__type_traits/is_convertible.h"151#include "__type_traits/remove_cv.h"152#include "__type_traits/remove_pointer.h"153#include "__type_traits/type_identity.h"154#include "__type_traits/void_t.h"155#include "__utility/declval.h"156#include "array"157#include "cstddef" // for ptrdiff_t158#include "version"159 160#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)161# pragma GCC system_header162#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)163# pragma clang system_header164#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)165# pragma system_header166#endif // no system header167 168_LIBCUDACXX_BEGIN_NAMESPACE_STD169 170#if _LIBCUDACXX_STD_VER > 11171 172template <class _Tp>173struct __is_span_impl : public false_type {};174 175template <class _Tp, size_t _Extent>176struct __is_span_impl<span<_Tp, _Extent>> : public true_type {};177 178template <class _Tp>179struct __is_span : public __is_span_impl<remove_cv_t<_Tp>> {};180 181template <class _Tp>182struct __is_std_array_impl : public false_type {};183 184template <class _Tp, size_t _Sz>185struct __is_std_array_impl<array<_Tp, _Sz>> : public true_type {};186 187template <class _Tp>188struct __is_std_array : public __is_std_array_impl<remove_cv_t<_Tp>> {};189 190template <class _Tp, class _ElementType, class = void>191struct __is_span_compatible_container : public false_type {};192 193template <class _Tp, class _ElementType>194struct __is_span_compatible_container<_Tp, _ElementType,195 void_t<196 // is not a specialization of span197 enable_if_t<!__is_span<_Tp>::value, nullptr_t>,198 // is not a specialization of array199 enable_if_t<!__is_std_array<_Tp>::value, nullptr_t>,200 // is_array_v<Container> is false,201 enable_if_t<!_LIBCUDACXX_TRAIT(is_array, _Tp), nullptr_t>,202 // data(cont) and size(cont) are well formed203 decltype(data(declval<_Tp>())),204 decltype(size(declval<_Tp>())),205 // remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[]206 enable_if_t<207 is_convertible<remove_pointer_t<decltype(data(declval<_Tp &>()))>(*)[],208 _ElementType(*)[]>::value,209 nullptr_t>210 >>211 : public true_type {};212 213template <typename _Tp, size_t _Extent>214class _LIBCUDACXX_TEMPLATE_VIS span {215public:216// constants and types217 using element_type = _Tp;218 using value_type = remove_cv_t<_Tp>;219 using size_type = size_t;220 using difference_type = ptrdiff_t;221 using pointer = _Tp *;222 using const_pointer = const _Tp *;223 using reference = _Tp &;224 using const_reference = const _Tp &;225 using iterator = __wrap_iter<pointer>;226 using reverse_iterator = _CUDA_VSTD::reverse_iterator<iterator>;227 228 static constexpr size_type extent = _Extent;229 230// [span.cons], span constructors, copy, assignment, and destructor231 template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, int> = 0>232 _LIBCUDACXX_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {}233 234 span (const span&) noexcept = default;235 span& operator=(const span&) noexcept = default;236 237 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span(pointer __ptr, size_type __count) : __data{__ptr}238 { (void)__count; _LIBCUDACXX_ASSERT(_Extent == __count, "size mismatch in span's constructor (ptr, len)"); }239 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span(pointer __f, pointer __l) : __data{__f}240 { (void)__l; _LIBCUDACXX_ASSERT(_Extent == distance(__f, __l), "size mismatch in span's constructor (ptr, ptr)"); }241#if defined(_LIBCUDACXX_COMPILER_NVRTC) \242 || defined(_LIBCUDACXX_COMPILER_MSVC_2017)243 template <size_t _Sz = _Extent, enable_if_t<_Sz != 0, int> = 0>244 _LIBCUDACXX_INLINE_VISIBILITY constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept : __data{__arr} {}245#else246 _LIBCUDACXX_INLINE_VISIBILITY constexpr span(type_identity_t<element_type> (&__arr)[_Extent]) noexcept : __data{__arr} {}247#endif248 template <class _OtherElementType,249 enable_if_t< _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type (*)[]), int> = 0>250 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14251 span( array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}252 template <class _OtherElementType,253 enable_if_t< _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type (*)[]), int> = 0>254 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14255 span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}256 257 template <class _OtherElementType,258#ifdef _LIBCUDACXX_COMPILER_MSVC_2017259 size_t _Extent2 = _Extent, enable_if_t< _Extent2 != dynamic_extent, int> = 0,260#endif // _LIBCUDACXX_COMPILER_MSVC_2017261 enable_if_t<!_LIBCUDACXX_TRAIT(is_same, _OtherElementType, _Tp), int> = 0,262 enable_if_t< _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type (*)[]), int> = 0>263 _LIBCUDACXX_INLINE_VISIBILITY264 constexpr span(const span<_OtherElementType, _Extent>& __other) noexcept265 : __data{__other.data()} {}266 267 template <class _OtherElementType,268 enable_if_t<!_LIBCUDACXX_TRAIT(is_same, _OtherElementType, _Tp), int> = 0,269 enable_if_t< _LIBCUDACXX_TRAIT(is_convertible, _OtherElementType(*)[], element_type (*)[]), int> = 0>270 _LIBCUDACXX_INLINE_VISIBILITY271 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span(const span<_OtherElementType, dynamic_extent>& __other) noexcept272 : __data{__other.data()} { _LIBCUDACXX_ASSERT(_Extent == __other.size(), "size mismatch in span's constructor (other span)"); }273 274 template <class _Container, enable_if_t<275 __is_span_compatible_container<_Container, _Tp>::value, int> = 0>276 _LIBCUDACXX_INLINE_VISIBILITY277 constexpr span( _Container& __c) noexcept(noexcept(_CUDA_VSTD::data(__c)))278 : __data{_CUDA_VSTD::data(__c)} { _LIBCUDACXX_ASSERT(_Extent == _CUDA_VSTD::size(__c), "size mismatch in span's constructor (other span)"); }279 280 template <class _Container, enable_if_t<281 __is_span_compatible_container<_Container, _Tp>::value, int> = 0>282 _LIBCUDACXX_INLINE_VISIBILITY283 constexpr span(const _Container& __c) noexcept(noexcept(_CUDA_VSTD::data(__c)))284 : __data{_CUDA_VSTD::data(__c)} { _LIBCUDACXX_ASSERT(_Extent == _CUDA_VSTD::size(__c), "size mismatch in span's constructor (other span)"); }285 286// ~span() noexcept = default;287 288 template <size_t _Count>289 _LIBCUDACXX_INLINE_VISIBILITY290 constexpr span<element_type, _Count> first() const noexcept291 {292 static_assert(_Count <= _Extent, "span<T, N>::first<Count>(): Count out of range");293 return {data(), _Count};294 }295 296 template <size_t _Count>297 _LIBCUDACXX_INLINE_VISIBILITY298 constexpr span<element_type, _Count> last() const noexcept299 {300 static_assert(_Count <= _Extent, "span<T, N>::last<Count>(): Count out of range");301 return {data() + size() - _Count, _Count};302 }303 304 _LIBCUDACXX_INLINE_VISIBILITY305 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent> first(size_type __count) const noexcept306 {307 _LIBCUDACXX_ASSERT(__count <= size(), "span<T, N>::first(count): count out of range");308 return {data(), __count};309 }310 311 _LIBCUDACXX_INLINE_VISIBILITY312 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent> last(size_type __count) const noexcept313 {314 _LIBCUDACXX_ASSERT(__count <= size(), "span<T, N>::last(count): count out of range");315 return {data() + size() - __count, __count};316 }317 318 template <size_t _Offset, size_t _Count>319 using __subspan_t = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;320 321 template <size_t _Offset, size_t _Count = dynamic_extent>322 _LIBCUDACXX_INLINE_VISIBILITY323 constexpr __subspan_t<_Offset, _Count> subspan() const noexcept324 {325 static_assert(_Offset <= _Extent, "span<T, N>::subspan<Offset, Count>(): Offset out of range");326 static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset, "span<T, N>::subspan<Offset, Count>(): Offset + Count out of range");327 return __subspan_t<_Offset, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};328 }329 330 _LIBCUDACXX_INLINE_VISIBILITY331 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent>332 subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept333 {334 _LIBCUDACXX_ASSERT(__offset <= size(), "span<T, N>::subspan(offset, count): offset out of range");335 _LIBCUDACXX_ASSERT(__count <= size() || __count == dynamic_extent, "span<T, N>::subspan(offset, count): count out of range");336 if (__count == dynamic_extent)337 return {data() + __offset, size() - __offset};338 _LIBCUDACXX_ASSERT(__count <= size() - __offset, "span<T, N>::subspan(offset, count): offset + count out of range");339 return {data() + __offset, __count};340 }341 342 _LIBCUDACXX_INLINE_VISIBILITY constexpr size_type size() const noexcept { return _Extent; }343 _LIBCUDACXX_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }344 _LIBCUDACXX_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }345 346 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference operator[](size_type __idx) const noexcept347 {348 _LIBCUDACXX_ASSERT(__idx < size(), "span<T, N>::operator[](index): index out of range");349 return __data[__idx];350 }351 352 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference front() const noexcept353 {354 _LIBCUDACXX_ASSERT(!empty(), "span<T, N>::front() on empty span");355 return __data[0];356 }357 358 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference back() const noexcept359 {360 _LIBCUDACXX_ASSERT(!empty(), "span<T, N>::back() on empty span");361 return __data[size()-1];362 }363 364 _LIBCUDACXX_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }365 366// [span.iter], span iterator support367 _LIBCUDACXX_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }368 _LIBCUDACXX_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }369 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }370 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }371 372 _LIBCUDACXX_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept373 { return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()}; }374 375 _LIBCUDACXX_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept376 { return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }377 378private:379 pointer __data;380};381 382 383template <typename _Tp>384class _LIBCUDACXX_TEMPLATE_VIS span<_Tp, dynamic_extent> {385public:386// constants and types387 using element_type = _Tp;388 using value_type = remove_cv_t<_Tp>;389 using size_type = size_t;390 using difference_type = ptrdiff_t;391 using pointer = _Tp *;392 using const_pointer = const _Tp *;393 using reference = _Tp &;394 using const_reference = const _Tp &;395 using iterator = __wrap_iter<pointer>;396 using reverse_iterator = _CUDA_VSTD::reverse_iterator<iterator>;397 398 static constexpr size_type extent = dynamic_extent;399 400// [span.cons], span constructors, copy, assignment, and destructor401 _LIBCUDACXX_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}402 403 span (const span&) noexcept = default;404 span& operator=(const span&) noexcept = default;405 406 _LIBCUDACXX_INLINE_VISIBILITY constexpr span(pointer __ptr, size_type __count) : __data{__ptr}, __size{__count} {}407#if _LIBCUDACXX_STD_VER > 14408 _LIBCUDACXX_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<size_t>(distance(__f, __l))} {}409#else410 _LIBCUDACXX_INLINE_VISIBILITY constexpr span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<size_t>(__l - __f)} {}411#endif412 413 template <size_t _Sz>414 _LIBCUDACXX_INLINE_VISIBILITY415 constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}416 417 template <class _OtherElementType, size_t _Sz, enable_if_t<418 is_convertible<_OtherElementType(*)[], element_type (*)[]>::value, int> = 0>419 _LIBCUDACXX_INLINE_VISIBILITY420 _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 span(array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}421 422 template <class _OtherElementType, size_t _Sz, enable_if_t<423 is_convertible<_OtherElementType(*)[], element_type (*)[]>::value, int> = 0>424 _LIBCUDACXX_INLINE_VISIBILITY425 _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}426 427 template <class _Container, enable_if_t<428 __is_span_compatible_container<_Container, _Tp>::value, int> = 0>429 _LIBCUDACXX_INLINE_VISIBILITY430 constexpr span( _Container& __c)431 : __data{_CUDA_VSTD::data(__c)}, __size{(size_type) _CUDA_VSTD::size(__c)} {}432 433 template <class _Container, enable_if_t<434 __is_span_compatible_container<_Container, _Tp>::value, int> = 0>435 _LIBCUDACXX_INLINE_VISIBILITY436 constexpr span(const _Container& __c)437 : __data{_CUDA_VSTD::data(__c)}, __size{(size_type) _CUDA_VSTD::size(__c)} {}438 439 440 template <class _OtherElementType, size_t _OtherExtent, enable_if_t<441 is_convertible<_OtherElementType(*)[], element_type (*)[]>::value, int> = 0>442 _LIBCUDACXX_INLINE_VISIBILITY443 constexpr span(const span<_OtherElementType, _OtherExtent>& __other) noexcept444 : __data{__other.data()}, __size{__other.size()} {}445 446// ~span() noexcept = default;447 448 template <size_t _Count>449 _LIBCUDACXX_INLINE_VISIBILITY450 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, _Count> first() const noexcept451 {452 _LIBCUDACXX_ASSERT(_Count <= size(), "span<T>::first<Count>(): Count out of range");453 return span<element_type, _Count>{data(), _Count};454 }455 456 template <size_t _Count>457 _LIBCUDACXX_INLINE_VISIBILITY458 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, _Count> last() const noexcept459 {460 _LIBCUDACXX_ASSERT(_Count <= size(), "span<T>::last<Count>(): Count out of range");461 return span<element_type, _Count>{data() + size() - _Count, _Count};462 }463 464 _LIBCUDACXX_INLINE_VISIBILITY465 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent> first(size_type __count) const noexcept466 {467 _LIBCUDACXX_ASSERT(__count <= size(), "span<T>::first(count): count out of range");468 return {data(), __count};469 }470 471 _LIBCUDACXX_INLINE_VISIBILITY472 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent> last (size_type __count) const noexcept473 {474 _LIBCUDACXX_ASSERT(__count <= size(), "span<T>::last(count): count out of range");475 return {data() + size() - __count, __count};476 }477 478 template <size_t _Offset, size_t _Count>479 using __subspan_t = span<element_type, _Count>;480 481 template <size_t _Offset, size_t _Count = dynamic_extent>482 _LIBCUDACXX_INLINE_VISIBILITY483 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 __subspan_t<_Offset, _Count> subspan() const noexcept484 {485 _LIBCUDACXX_ASSERT(_Offset <= size(), "span<T>::subspan<Offset, Count>(): Offset out of range");486 _LIBCUDACXX_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "span<T>::subspan<Offset, Count>(): Offset + Count out of range");487 return __subspan_t<_Offset, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};488 }489 490 _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 span<element_type, dynamic_extent>491 _LIBCUDACXX_INLINE_VISIBILITY492 subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept493 {494 _LIBCUDACXX_ASSERT(__offset <= size(), "span<T>::subspan(offset, count): offset out of range");495 _LIBCUDACXX_ASSERT(__count <= size() || __count == dynamic_extent, "span<T>::subspan(offset, count): count out of range");496 if (__count == dynamic_extent)497 return {data() + __offset, size() - __offset};498 _LIBCUDACXX_ASSERT(__count <= size() - __offset, "span<T>::subspan(offset, count): offset + count out of range");499 return {data() + __offset, __count};500 }501 502 _LIBCUDACXX_INLINE_VISIBILITY constexpr size_type size() const noexcept { return __size; }503 _LIBCUDACXX_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return __size * sizeof(element_type); }504 _LIBCUDACXX_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size == 0; }505 506 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference operator[](size_type __idx) const noexcept507 {508 _LIBCUDACXX_ASSERT(__idx < size(), "span<T>::operator[](index): index out of range");509 return __data[__idx];510 }511 512 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference front() const noexcept513 {514 _LIBCUDACXX_ASSERT(!empty(), "span<T>::front() on empty span");515 return __data[0];516 }517 518 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX11 reference back() const noexcept519 {520 _LIBCUDACXX_ASSERT(!empty(), "span<T>::back() on empty span");521 return __data[size()-1];522 }523 524 525 _LIBCUDACXX_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }526 527// [span.iter], span iterator support528 _LIBCUDACXX_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }529 _LIBCUDACXX_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }530 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }531 _LIBCUDACXX_INLINE_VISIBILITY _LIBCUDACXX_CONSTEXPR_AFTER_CXX14 reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }532 533 _LIBCUDACXX_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept534 { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }535 536 _LIBCUDACXX_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept537 { return {reinterpret_cast<byte *>(data()), size_bytes()}; }538 539private:540 pointer __data;541 size_type __size;542};543 544// as_bytes & as_writable_bytes545template <class _Tp, size_t _Extent>546_LIBCUDACXX_INLINE_VISIBILITY547auto as_bytes(span<_Tp, _Extent> __s) noexcept548-> decltype(__s.__as_bytes())549{ return __s.__as_bytes(); }550 551template <class _Tp, size_t _Extent>552_LIBCUDACXX_INLINE_VISIBILITY553auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept554-> enable_if_t<!is_const<_Tp>::value, decltype(__s.__as_writable_bytes())>555{ return __s.__as_writable_bytes(); }556 557#endif // _LIBCUDACXX_STD_VER > 11558 559#if _LIBCUDACXX_STD_VER > 14 && !defined(_LIBCUDACXX_HAS_NO_DEDUCTION_GUIDES)560 561// Deduction guides562template<class _Tp, size_t _Sz>563_LIBCUDACXX_HOST_DEVICE span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;564 565template<class _Tp, size_t _Sz>566_LIBCUDACXX_HOST_DEVICE span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;567 568template<class _Tp, size_t _Sz>569_LIBCUDACXX_HOST_DEVICE span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;570 571template<class _Container>572_LIBCUDACXX_HOST_DEVICE span(_Container&) -> span<typename _Container::value_type>;573 574template<class _Container>575_LIBCUDACXX_HOST_DEVICE span(const _Container&) -> span<const typename _Container::value_type>;576 577#endif // _LIBCUDACXX_STD_VER > 14578 579_LIBCUDACXX_END_NAMESPACE_STD580 581#endif // _LIBCUDACXX_SPAN582