459 lines
20 KiB
C++
459 lines
20 KiB
C++
// -*- C++ -*-
|
|
//===------------------------------ span ---------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
#ifndef _WTF_LIBCPP_SPAN
|
|
#define _WTF_LIBCPP_SPAN
|
|
|
|
// Imports a copy of <span> from e892705d74c7366a1404a3b3471001edaa7659f8 of the
|
|
// libc++ project (https://github.com/llvm/llvm-project.git) and modifies it to
|
|
// work on top of any standard library implementation.
|
|
//
|
|
// - Renames macros with _LIBCPP_ prefix to use the prefix _WTF_LIBCPP_
|
|
// - Renames std::span to WTF::Span
|
|
// - Renames std::as_bytes/std::as_writable_bytes to WTF::asBytes/WTF::asWritableBytes.
|
|
// - Stop #including internal libc++ headers.
|
|
// - Remove check for > c++17.
|
|
// - Remove push/pop availability of min/max macros.
|
|
|
|
#include <array> // for array
|
|
#include <cstddef> // for byte
|
|
#include <iterator> // for iterators
|
|
#include <type_traits> // for remove_cv, etc
|
|
|
|
// Adds some macro defines usually defined in __config.
|
|
|
|
#define _WTF_LIBCPP_ABI_SPAN_POINTER_ITERATORS
|
|
#define _WTF_LIBCPP_BEGIN_NAMESPACE namespace WTF {
|
|
#define _WTF_LIBCPP_DEBUG_LEVEL 0
|
|
#define _WTF_LIBCPP_END_NAMESPACE }
|
|
#define _WTF_LIBCPP_HAS_NO_RANGES
|
|
#define _WTF_LIBCPP_INLINE_VISIBILITY
|
|
#define _WTF_LIBCPP_TEMPLATE_VIS
|
|
#define _WTF_VSTD std
|
|
|
|
#include <wtf/Assertions.h>
|
|
#define _WTF_LIBCPP_ASSERT ASSERT
|
|
|
|
_WTF_LIBCPP_BEGIN_NAMESPACE
|
|
|
|
inline constexpr std::size_t dynamic_extent = std::numeric_limits<std::size_t>::max();
|
|
template <typename _Tp, std::size_t _Extent = dynamic_extent> class Span;
|
|
|
|
|
|
template <class _Tp>
|
|
struct __is_span_impl : public std::false_type {};
|
|
|
|
template <class _Tp, std::size_t _Extent>
|
|
struct __is_span_impl<Span<_Tp, _Extent>> : public std::true_type {};
|
|
|
|
template <class _Tp>
|
|
struct __is_span : public __is_span_impl<std::remove_cv_t<_Tp>> {};
|
|
|
|
template <class _Tp>
|
|
struct __is_std_array_impl : public std::false_type {};
|
|
|
|
template <class _Tp, std::size_t _Sz>
|
|
struct __is_std_array_impl<std::array<_Tp, _Sz>> : public std::true_type {};
|
|
|
|
template <class _Tp>
|
|
struct __is_std_array : public __is_std_array_impl<std::remove_cv_t<_Tp>> {};
|
|
|
|
template <class _Tp, class _ElementType, class = void>
|
|
struct __is_span_compatible_container : public std::false_type {};
|
|
|
|
template <class _Tp, class _ElementType>
|
|
struct __is_span_compatible_container<_Tp, _ElementType,
|
|
std::void_t<
|
|
// is not a specialization of Span
|
|
typename std::enable_if<!__is_span<_Tp>::value, std::nullptr_t>::type,
|
|
// is not a specialization of array
|
|
typename std::enable_if<!__is_std_array<_Tp>::value, std::nullptr_t>::type,
|
|
// sd::is_array_v<Container> is false,
|
|
typename std::enable_if<!std::is_array_v<_Tp>, std::nullptr_t>::type,
|
|
// std::data(cont) and std::size(cont) are well formed
|
|
decltype(std::data(std::declval<_Tp>())),
|
|
decltype(std::size(std::declval<_Tp>())),
|
|
// remove_pointer_t<decltype(data(cont))>(*)[] is convertible to ElementType(*)[]
|
|
typename std::enable_if<
|
|
std::is_convertible_v<std::remove_pointer_t<decltype(std::data(std::declval<_Tp &>()))>(*)[],
|
|
_ElementType(*)[]>,
|
|
std::nullptr_t>::type
|
|
>>
|
|
: public std::true_type {};
|
|
|
|
|
|
template <typename _Tp, std::size_t _Extent>
|
|
class _WTF_LIBCPP_TEMPLATE_VIS Span {
|
|
public:
|
|
// constants and types
|
|
using element_type = _Tp;
|
|
using value_type = std::remove_cv_t<_Tp>;
|
|
using size_type = std::size_t;
|
|
using difference_type = std::ptrdiff_t;
|
|
using pointer = _Tp *;
|
|
using const_pointer = const _Tp *;
|
|
using reference = _Tp &;
|
|
using const_reference = const _Tp &;
|
|
#if (_WTF_LIBCPP_DEBUG_LEVEL == 2) || defined(_WTF_LIBCPP_ABI_SPAN_POINTER_ITERATORS)
|
|
using iterator = pointer;
|
|
#else
|
|
using iterator = __wrap_iter<pointer>;
|
|
#endif
|
|
using reverse_iterator = _WTF_VSTD::reverse_iterator<iterator>;
|
|
|
|
static constexpr size_type extent = _Extent;
|
|
|
|
// [span.cons], span constructors, copy, assignment, and destructor
|
|
template <std::size_t _Sz = _Extent, std::enable_if_t<_Sz == 0, std::nullptr_t> = nullptr>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr Span() noexcept : __data{nullptr} {}
|
|
|
|
constexpr Span (const Span&) noexcept = default;
|
|
constexpr Span& operator=(const Span&) noexcept = default;
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr explicit Span(pointer __ptr, size_type __count) : __data{__ptr}
|
|
{ (void)__count; _WTF_LIBCPP_ASSERT(_Extent == __count, "size mismatch in Span's constructor (ptr, len)"); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr explicit Span(pointer __f, pointer __l) : __data{__f}
|
|
{ (void)__l; _WTF_LIBCPP_ASSERT(_Extent == std::distance(__f, __l), "size mismatch in Span's constructor (ptr, ptr)"); }
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr Span(element_type (&__arr)[_Extent]) noexcept : __data{__arr} {}
|
|
|
|
template <class _OtherElementType,
|
|
std::enable_if_t<std::is_convertible_v<_OtherElementType(*)[], element_type (*)[]>, std::nullptr_t> = nullptr>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(std::array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
|
|
|
|
template <class _OtherElementType,
|
|
std::enable_if_t<std::is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, std::nullptr_t> = nullptr>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(const std::array<_OtherElementType, _Extent>& __arr) noexcept : __data{__arr.data()} {}
|
|
|
|
template <class _Container>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr explicit Span( _Container& __c,
|
|
std::enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, std::nullptr_t> = nullptr)
|
|
: __data{_WTF_VSTD::data(__c)} {
|
|
_WTF_LIBCPP_ASSERT(_Extent == _WTF_VSTD::size(__c), "size mismatch in Span's constructor (range)");
|
|
}
|
|
|
|
template <class _Container>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr explicit Span(const _Container& __c,
|
|
std::enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, std::nullptr_t> = nullptr)
|
|
: __data{_WTF_VSTD::data(__c)} {
|
|
_WTF_LIBCPP_ASSERT(_Extent == _WTF_VSTD::size(__c), "size mismatch in Span's constructor (range)");
|
|
}
|
|
|
|
template <class _OtherElementType>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(const Span<_OtherElementType, _Extent>& __other,
|
|
std::enable_if_t<
|
|
std::is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
|
|
std::nullptr_t> = nullptr)
|
|
: __data{__other.data()} {}
|
|
|
|
template <class _OtherElementType>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr explicit Span(const Span<_OtherElementType>& __other,
|
|
std::enable_if_t<
|
|
std::is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
|
|
std::nullptr_t> = nullptr) noexcept
|
|
: __data{__other.data()} { _WTF_LIBCPP_ASSERT(_Extent == __other.size(), "size mismatch in Span's constructor (other Span)"); }
|
|
|
|
|
|
// ~Span() noexcept = default;
|
|
|
|
template <std::size_t _Count>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, _Count> first() const noexcept
|
|
{
|
|
static_assert(_Count <= _Extent, "Count out of range in Span::first()");
|
|
return Span<element_type, _Count>{data(), _Count};
|
|
}
|
|
|
|
template <std::size_t _Count>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, _Count> last() const noexcept
|
|
{
|
|
static_assert(_Count <= _Extent, "Count out of range in Span::last()");
|
|
return Span<element_type, _Count>{data() + size() - _Count, _Count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, dynamic_extent> first(size_type __count) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__count <= size(), "Count out of range in Span::first(count)");
|
|
return {data(), __count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, dynamic_extent> last(size_type __count) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__count <= size(), "Count out of range in Span::last(count)");
|
|
return {data() + size() - __count, __count};
|
|
}
|
|
|
|
template <std::size_t _Offset, std::size_t _Count = dynamic_extent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr auto subspan() const noexcept
|
|
-> Span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>
|
|
{
|
|
static_assert(_Offset <= _Extent, "Offset out of range in Span::subspan()");
|
|
static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset, "Offset + count out of range in Span::subspan()");
|
|
|
|
using _ReturnType = Span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
|
|
return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
|
|
}
|
|
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, dynamic_extent>
|
|
subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in Span::subspan(offset, count)");
|
|
_WTF_LIBCPP_ASSERT(__count <= size() || __count == dynamic_extent, "Count out of range in Span::subspan(offset, count)");
|
|
if (__count == dynamic_extent)
|
|
return {data() + __offset, size() - __offset};
|
|
_WTF_LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in Span::subspan(offset, count)");
|
|
return {data() + __offset, __count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr size_type size() const noexcept { return _Extent; }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__idx < size(), "Span<T,N>[] index out of bounds");
|
|
return __data[__idx];
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(!empty(), "Span<T, N>::front() on empty Span");
|
|
return __data[0];
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(!empty(), "Span<T, N>::back() on empty Span");
|
|
return __data[size()-1];
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }
|
|
|
|
// [span.iter], Span iterator support
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
|
|
|
|
private:
|
|
pointer __data;
|
|
|
|
};
|
|
|
|
|
|
template <typename _Tp>
|
|
class _WTF_LIBCPP_TEMPLATE_VIS Span<_Tp, dynamic_extent> {
|
|
private:
|
|
|
|
public:
|
|
// constants and types
|
|
using element_type = _Tp;
|
|
using value_type = std::remove_cv_t<_Tp>;
|
|
using size_type = std::size_t;
|
|
using difference_type = std::ptrdiff_t;
|
|
using pointer = _Tp *;
|
|
using const_pointer = const _Tp *;
|
|
using reference = _Tp &;
|
|
using const_reference = const _Tp &;
|
|
#if (_WTF_LIBCPP_DEBUG_LEVEL == 2) || defined(_WTF_LIBCPP_ABI_SPAN_POINTER_ITERATORS)
|
|
using iterator = pointer;
|
|
#else
|
|
using iterator = __wrap_iter<pointer>;
|
|
#endif
|
|
using reverse_iterator = _WTF_VSTD::reverse_iterator<iterator>;
|
|
|
|
static constexpr size_type extent = dynamic_extent;
|
|
|
|
// [span.cons], Span constructors, copy, assignment, and destructor
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr Span() noexcept : __data{nullptr}, __size{0} {}
|
|
|
|
constexpr Span (const Span&) noexcept = default;
|
|
constexpr Span& operator=(const Span&) noexcept = default;
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr Span(pointer __ptr, size_type __count) : __data{__ptr}, __size{__count} {}
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr Span(pointer __f, pointer __l) : __data{__f}, __size{static_cast<std::size_t>(std::distance(__f, __l))} {}
|
|
|
|
template <std::size_t _Sz>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(element_type (&__arr)[_Sz]) noexcept : __data{__arr}, __size{_Sz} {}
|
|
|
|
template <class _OtherElementType, std::size_t _Sz,
|
|
std::enable_if_t<std::is_convertible_v<_OtherElementType(*)[], element_type (*)[]>, std::nullptr_t> = nullptr>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(std::array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
|
|
|
|
template <class _OtherElementType, std::size_t _Sz,
|
|
std::enable_if_t<std::is_convertible_v<const _OtherElementType(*)[], element_type (*)[]>, std::nullptr_t> = nullptr>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(const std::array<_OtherElementType, _Sz>& __arr) noexcept : __data{__arr.data()}, __size{_Sz} {}
|
|
|
|
template <class _Container>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span( _Container& __c,
|
|
std::enable_if_t<__is_span_compatible_container<_Container, _Tp>::value, std::nullptr_t> = nullptr)
|
|
: __data{_WTF_VSTD::data(__c)}, __size{(size_type) _WTF_VSTD::size(__c)} {}
|
|
|
|
template <class _Container>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(const _Container& __c,
|
|
std::enable_if_t<__is_span_compatible_container<const _Container, _Tp>::value, std::nullptr_t> = nullptr)
|
|
: __data{_WTF_VSTD::data(__c)}, __size{(size_type) _WTF_VSTD::size(__c)} {}
|
|
|
|
|
|
template <class _OtherElementType, std::size_t _OtherExtent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span(const Span<_OtherElementType, _OtherExtent>& __other,
|
|
std::enable_if_t<
|
|
std::is_convertible_v<_OtherElementType(*)[], element_type (*)[]>,
|
|
std::nullptr_t> = nullptr) noexcept
|
|
: __data{__other.data()}, __size{__other.size()} {}
|
|
|
|
// ~Span() noexcept = default;
|
|
|
|
template <std::size_t _Count>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, _Count> first() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(_Count <= size(), "Count out of range in Span::first()");
|
|
return Span<element_type, _Count>{data(), _Count};
|
|
}
|
|
|
|
template <std::size_t _Count>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, _Count> last() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(_Count <= size(), "Count out of range in Span::last()");
|
|
return Span<element_type, _Count>{data() + size() - _Count, _Count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, dynamic_extent> first(size_type __count) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__count <= size(), "Count out of range in Span::first(count)");
|
|
return {data(), __count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, dynamic_extent> last (size_type __count) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__count <= size(), "Count out of range in Span::last(count)");
|
|
return {data() + size() - __count, __count};
|
|
}
|
|
|
|
template <std::size_t _Offset, std::size_t _Count = dynamic_extent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
constexpr Span<element_type, _Count> subspan() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(_Offset <= size(), "Offset out of range in Span::subspan()");
|
|
_WTF_LIBCPP_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "Offset + count out of range in Span::subspan()");
|
|
return Span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
|
|
}
|
|
|
|
constexpr Span<element_type, dynamic_extent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__offset <= size(), "Offset out of range in Span::subspan(offset, count)");
|
|
_WTF_LIBCPP_ASSERT(__count <= size() || __count == dynamic_extent, "count out of range in Span::subspan(offset, count)");
|
|
if (__count == dynamic_extent)
|
|
return {data() + __offset, size() - __offset};
|
|
_WTF_LIBCPP_ASSERT(__count <= size() - __offset, "Offset + count out of range in Span::subspan(offset, count)");
|
|
return {data() + __offset, __count};
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr size_type size() const noexcept { return __size; }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes() const noexcept { return __size * sizeof(element_type); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size == 0; }
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(__idx < size(), "Span<T>[] index out of bounds");
|
|
return __data[__idx];
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(!empty(), "Span<T>[].front() on empty Span");
|
|
return __data[0];
|
|
}
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
|
|
{
|
|
_WTF_LIBCPP_ASSERT(!empty(), "Span<T>[].back() on empty Span");
|
|
return __data[size()-1];
|
|
}
|
|
|
|
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr pointer data() const noexcept { return __data; }
|
|
|
|
// [span.iter], Span iterator support
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept { return iterator(data()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept { return iterator(data() + size()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
|
|
_WTF_LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
|
|
|
|
private:
|
|
pointer __data;
|
|
size_type __size;
|
|
};
|
|
|
|
#if !defined(_WTF_LIBCPP_HAS_NO_RANGES)
|
|
template <class _Tp, std::size_t _Extent>
|
|
inline constexpr bool std::ranges::enable_borrowed_range<Span<_Tp, _Extent> > = true;
|
|
#endif // !defined(_WTF_LIBCPP_HAS_NO_RANGES)
|
|
|
|
// asBytes & asWritableBytes
|
|
template <class _Tp, std::size_t _Extent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
auto asBytes(Span<_Tp, _Extent> __s) noexcept
|
|
-> Span<const std::byte, _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(_Tp)>
|
|
{ return { reinterpret_cast<const std::byte *>(__s.data()), __s.size_bytes() }; }
|
|
|
|
template <class _Tp, std::size_t _Extent>
|
|
_WTF_LIBCPP_INLINE_VISIBILITY
|
|
auto asWritableBytes(Span<_Tp, _Extent> __s) noexcept
|
|
-> std::enable_if_t<!std::is_const_v<_Tp>, Span<std::byte, _Extent == dynamic_extent ? dynamic_extent : _Extent * sizeof(_Tp)>>
|
|
{ return { reinterpret_cast<std::byte *>(__s.data()), __s.size_bytes() }; }
|
|
|
|
// Deduction guides
|
|
template<class _Tp, std::size_t _Sz>
|
|
Span(_Tp (&)[_Sz]) -> Span<_Tp, _Sz>;
|
|
|
|
template<class _Tp, std::size_t _Sz>
|
|
Span(std::array<_Tp, _Sz>&) -> Span<_Tp, _Sz>;
|
|
|
|
template<class _Tp, std::size_t _Sz>
|
|
Span(const std::array<_Tp, _Sz>&) -> Span<const _Tp, _Sz>;
|
|
|
|
template<class _Container>
|
|
Span(_Container&) -> Span<typename _Container::value_type>;
|
|
|
|
template<class _Container>
|
|
Span(const _Container&) -> Span<const typename _Container::value_type>;
|
|
|
|
_WTF_LIBCPP_END_NAMESPACE
|
|
|
|
using WTF::Span;
|
|
using WTF::asBytes;
|
|
using WTF::asWritableBytes;
|
|
|
|
#endif // _WTF_LIBCPP_SPAN
|