35 #define _GLIBCXX_SPAN 1
37 #pragma GCC system_header
39 #if __cplusplus > 201703L
41 #include <type_traits>
46 #if __cpp_lib_concepts
47 namespace std _GLIBCXX_VISIBILITY(default)
49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
51 #define __cpp_lib_span 201902L
53 inline constexpr
size_t dynamic_extent = static_cast<size_t>(-1);
55 template<
typename _Type,
size_t _Extent>
60 template<
typename _Tp>
63 template<
typename _Tp,
size_t _Num>
64 struct __is_std_span<span<_Tp, _Num>> :
true_type { };
66 template<
typename _Tp>
69 template<
typename _Tp,
size_t _Num>
70 struct __is_std_array<_GLIBCXX_STD_C::array<_Tp, _Num>> :
true_type { };
73 template<
typename _Tp,
size_t _Num>
74 struct __is_std_array<__debug::array<_Tp, _Num>> :
true_type { };
77 template<
size_t _Extent>
78 class __extent_storage
82 __extent_storage(
size_t) noexcept
85 static constexpr
size_t
91 class __extent_storage<dynamic_extent>
95 __extent_storage(
size_t __extent) noexcept
96 : _M_extent_value(__extent)
100 _M_extent() const noexcept
101 {
return this->_M_extent_value; }
104 size_t _M_extent_value;
108 template<
typename _Type,
size_t _Extent = dynamic_extent>
111 template<
size_t _Offset,
size_t _Count>
112 static constexpr
size_t
115 if constexpr (_Count != dynamic_extent)
117 else if constexpr (extent != dynamic_extent)
118 return _Extent - _Offset;
120 return dynamic_extent;
125 template<
typename _Tp,
size_t _ArrayExtent>
126 using __is_compatible_array = __and_<
127 bool_constant<(_Extent == dynamic_extent || _ArrayExtent == _Extent)>,
128 __is_array_convertible<_Type, _Tp>>;
130 template<
typename _Iter,
typename _Ref = iter_reference_t<_Iter>>
131 using __is_compatible_iterator = __and_<
132 bool_constant<contiguous_iterator<_Iter>>,
133 is_lvalue_reference<iter_reference_t<_Iter>>,
134 is_same<iter_value_t<_Iter>, remove_cvref_t<_Ref>>,
135 __is_array_convertible<_Type, remove_reference_t<_Ref>>>;
137 template<
typename _Range>
138 using __is_compatible_range
139 = __is_compatible_iterator<ranges::iterator_t<_Range>>;
143 using value_type = remove_cv_t<_Type>;
144 using element_type = _Type;
145 using size_type = size_t;
146 using reference = element_type&;
147 using const_reference =
const element_type&;
148 using pointer = _Type*;
149 using const_pointer =
const _Type*;
151 = __gnu_cxx::__normal_iterator<pointer, span>;
153 = __gnu_cxx::__normal_iterator<const_pointer, span>;
156 using difference_type = ptrdiff_t;
159 static inline constexpr
size_t extent = _Extent;
165 requires ((_Extent + 1u) <= 1u)
166 : _M_extent(0), _M_ptr(
nullptr)
170 span(
const span&) noexcept =
default;
172 template<
typename _Tp,
size_t _ArrayExtent>
173 requires (__is_compatible_array<_Tp, _ArrayExtent>::value)
175 span(_Tp (&__arr)[_ArrayExtent]) noexcept
176 : span(static_cast<pointer>(__arr), _ArrayExtent)
179 template<
typename _Tp,
size_t _ArrayExtent>
180 requires (__is_compatible_array<_Tp, _ArrayExtent>::value)
182 span(array<_Tp, _ArrayExtent>& __arr) noexcept
183 : span(static_cast<pointer>(__arr.data()), _ArrayExtent)
186 template<
typename _Tp,
size_t _ArrayExtent>
187 requires (__is_compatible_array<const _Tp, _ArrayExtent>::value)
189 span(
const array<_Tp, _ArrayExtent>& __arr) noexcept
190 : span(static_cast<pointer>(__arr.data()), _ArrayExtent)
193 template<ranges::contiguous_range _Range>
194 requires (_Extent == dynamic_extent)
195 && (!__detail::__is_std_span<remove_cvref_t<_Range>>::value)
196 && (!__detail::__is_std_array<remove_cvref_t<_Range>>::value)
197 && (!is_array_v<remove_reference_t<_Range>>)
198 && (__is_compatible_range<_Range>::value)
200 span(_Range&& __range)
201 noexcept(noexcept(ranges::data(__range))
202 && noexcept(ranges::size(__range)))
203 : span(ranges::data(__range), ranges::size(__range))
206 template<contiguous_iterator _ContiguousIterator,
207 sized_sentinel_for<_ContiguousIterator> _Sentinel>
208 requires (__is_compatible_iterator<_ContiguousIterator>::value)
209 && (!is_convertible_v<_Sentinel, size_type>)
211 span(_ContiguousIterator __first, _Sentinel __last)
212 noexcept(noexcept(__last - __first))
213 : _M_extent(static_cast<size_type>(__last - __first)),
214 _M_ptr(
std::to_address(__first))
216 if (_Extent != dynamic_extent)
217 __glibcxx_assert((__last - __first) == _Extent);
220 template<contiguous_iterator _ContiguousIterator>
221 requires (__is_compatible_iterator<_ContiguousIterator>::value)
223 span(_ContiguousIterator __first, size_type __count)
225 : _M_extent(__count), _M_ptr(std::to_address(__first))
226 { __glibcxx_assert(_Extent == dynamic_extent || __count == _Extent); }
228 template<
typename _OType,
size_t _OExtent>
229 requires (_Extent == dynamic_extent || _Extent == _OExtent)
230 && (__is_array_convertible<_Type, _OType>::value)
232 span(
const span<_OType, _OExtent>& __s) noexcept
233 : _M_extent(__s.size()), _M_ptr(__s.data())
239 operator=(
const span&) noexcept =
default;
244 size() const noexcept
245 {
return this->_M_extent._M_extent(); }
248 size_bytes() const noexcept
249 {
return this->_M_extent._M_extent() *
sizeof(element_type); }
251 [[nodiscard]] constexpr
bool
252 empty() const noexcept
253 {
return size() == 0; }
258 front() const noexcept
260 static_assert(extent != 0);
261 __glibcxx_assert(!empty());
262 return *this->_M_ptr;
266 back() const noexcept
268 static_assert(extent != 0);
269 __glibcxx_assert(!empty());
270 return *(this->_M_ptr + (size() - 1));
274 operator[](size_type __idx)
const noexcept
276 static_assert(extent != 0);
277 __glibcxx_assert(__idx < size());
278 return *(this->_M_ptr + __idx);
282 data() const noexcept
283 {
return this->_M_ptr; }
288 begin() const noexcept
289 {
return iterator(this->_M_ptr); }
291 constexpr const_iterator
293 {
return const_iterator(this->_M_ptr); }
297 {
return iterator(this->_M_ptr + this->size()); }
299 constexpr const_iterator
300 cend() const noexcept
301 {
return const_iterator(this->_M_ptr + this->size()); }
303 constexpr reverse_iterator
305 {
return reverse_iterator(this->
end()); }
307 constexpr const_reverse_iterator
309 {
return const_reverse_iterator(this->
cend()); }
311 constexpr reverse_iterator
312 rend() const noexcept
313 {
return reverse_iterator(this->
begin()); }
315 constexpr const_reverse_iterator
316 crend() const noexcept
317 {
return const_reverse_iterator(this->
cbegin()); }
321 template<
size_t _Count>
322 constexpr span<element_type, _Count>
323 first() const noexcept
325 if constexpr (_Extent == dynamic_extent)
326 __glibcxx_assert(_Count <= size());
328 static_assert(_Count <= extent);
329 return { this->data(), _Count };
332 constexpr span<element_type, dynamic_extent>
333 first(size_type __count)
const noexcept
335 __glibcxx_assert(__count <= size());
336 return { this->data(), __count };
339 template<
size_t _Count>
340 constexpr span<element_type, _Count>
341 last() const noexcept
343 if constexpr (_Extent == dynamic_extent)
344 __glibcxx_assert(_Count <= size());
346 static_assert(_Count <= extent);
347 return { this->data() + (this->size() - _Count), _Count };
350 constexpr span<element_type, dynamic_extent>
351 last(size_type __count)
const noexcept
353 __glibcxx_assert(__count <= size());
354 return { this->data() + (this->size() - __count), __count };
357 template<
size_t _Offset,
size_t _Count = dynamic_extent>
359 subspan() const noexcept
360 -> span<element_type, _S_subspan_extent<_Offset, _Count>()>
362 if constexpr (_Extent == dynamic_extent)
363 __glibcxx_assert(_Offset <= size());
365 static_assert(_Offset <= extent);
367 if constexpr (_Count == dynamic_extent)
368 return { this->data() + _Offset, this->size() - _Offset };
371 if constexpr (_Extent == dynamic_extent)
373 __glibcxx_assert(_Count <= size());
374 __glibcxx_assert(_Count <= (size() - _Offset));
378 static_assert(_Count <= extent);
379 static_assert(_Count <= (extent - _Offset));
381 return { this->data() + _Offset, _Count };
385 constexpr span<element_type, dynamic_extent>
386 subspan(size_type __offset, size_type __count = dynamic_extent)
const
389 __glibcxx_assert(__offset <= size());
390 if (__count == dynamic_extent)
391 __count = this->size() - __offset;
394 __glibcxx_assert(__count <= size());
395 __glibcxx_assert(__offset + __count <= size());
397 return {this->data() + __offset, __count};
401 [[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
407 template<
typename _Type,
size_t _ArrayExtent>
408 span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>;
410 template<
typename _Type,
size_t _ArrayExtent>
411 span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>;
413 template<
typename _Type,
size_t _ArrayExtent>
414 span(
const array<_Type, _ArrayExtent>&)
415 -> span<const _Type, _ArrayExtent>;
417 template<contiguous_iterator _Iter,
typename _Sentinel>
418 span(_Iter, _Sentinel)
419 -> span<remove_reference_t<iter_reference_t<_Iter>>>;
421 template<
typename _Range>
423 -> span<remove_reference_t<ranges::range_reference_t<_Range&>>>;
425 template<
typename _Type,
size_t _Extent>
427 span<
const byte, _Extent == dynamic_extent
428 ? dynamic_extent : _Extent *
sizeof(_Type)>
429 as_bytes(span<_Type, _Extent> __sp) noexcept
431 return {reinterpret_cast<const byte*>(__sp.data()), __sp.size_bytes()};
434 template<
typename _Type,
size_t _Extent>
436 span<byte, _Extent == dynamic_extent
437 ? dynamic_extent : _Extent *
sizeof(_Type)>
438 as_writable_bytes(span<_Type, _Extent> __sp) noexcept
440 return {reinterpret_cast<byte*>(__sp.data()), __sp.size_bytes()};
444 template<
size_t _Index,
typename _Type,
size_t _Extent>
446 get(span<_Type, _Extent> __sp) noexcept
448 static_assert(_Extent != dynamic_extent && _Index < _Extent,
449 "get<I> can only be used with a span of non-dynamic (fixed) extent");
453 template<
typename _Tp>
struct tuple_size;
454 template<
size_t __i,
typename _Tp>
struct tuple_element;
456 template<
typename _Type,
size_t _Extent>
457 struct tuple_size<span<_Type, _Extent>>
458 :
public integral_constant<size_t, _Extent>
460 static_assert(_Extent != dynamic_extent,
"tuple_size can only "
461 "be used with a span of non-dynamic (fixed) extent");
464 template<
size_t _Index,
typename _Type,
size_t _Extent>
465 struct tuple_element<_Index, span<_Type, _Extent>>
467 static_assert(_Extent != dynamic_extent,
"tuple_element can only "
468 "be used with a span of non-dynamic (fixed) extent");
469 static_assert(_Index < _Extent,
"Index is less than Extent");
475 template<
typename>
extern inline const bool enable_safe_range;
477 template<
typename _ElementType,
size_t _Extent>
478 inline constexpr
bool
479 enable_safe_range<span<_ElementType, _Extent>> =
true;
481 _GLIBCXX_END_NAMESPACE_VERSION
485 #endif // _GLIBCXX_SPAN