Loading...
Searching...
No Matches
v8-memory-span.h
Go to the documentation of this file.
1// Copyright 2021 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#ifndef INCLUDE_V8_MEMORY_SPAN_H_
6#define INCLUDE_V8_MEMORY_SPAN_H_
7
8#include <stddef.h>
9
10#include <array>
11#include <cstddef>
12#include <iterator>
13#include <type_traits>
14
15#include "v8config.h" // NOLINT(build/include_directory)
16
17// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping
18// support for old libstdc++ versions.
19#if __has_include(<version>)
20#include <version>
21#endif
22#if defined(__cpp_lib_three_way_comparison) && \
23 __cpp_lib_three_way_comparison >= 201711L
24#define V8_HAVE_SPACESHIP_OPERATOR 1
25#else
26#define V8_HAVE_SPACESHIP_OPERATOR 0
27#endif
28
29// TODO(pkasting): Make this block unconditional after dropping support for old
30// libstdc++ versions.
31#if __has_include(<ranges>)
32#include <ranges>
33
34namespace v8 {
35
36template <typename T>
37class V8_EXPORT MemorySpan;
38
39} // namespace v8
40
41// Mark `MemorySpan` as satisfying the `view` and `borrowed_range` concepts.
42// This should be done before the definition of `MemorySpan`, so that any
43// inlined calls to range functionality use the correct specializations.
44template <typename T>
45inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
46template <typename T>
47inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
48 true;
49#endif
50
51namespace v8 {
52
63template <typename T>
65 private:
67 template <typename From, typename To>
68 using is_array_convertible = std::is_convertible<From (*)[], To (*)[]>;
69 template <typename From, typename To>
70 static constexpr bool is_array_convertible_v =
71 is_array_convertible<From, To>::value;
72
73 template <typename It>
74 using iter_reference_t = decltype(*std::declval<It&>());
75
76 template <typename It, typename = void>
77 struct is_compatible_iterator : std::false_type {};
78 template <typename It>
79 struct is_compatible_iterator<
80 It,
81 std::void_t<
82 std::is_base_of<std::random_access_iterator_tag,
83 typename std::iterator_traits<It>::iterator_category>,
84 is_array_convertible<std::remove_reference_t<iter_reference_t<It>>,
85 T>>> : std::true_type {};
86 template <typename It>
87 static constexpr bool is_compatible_iterator_v =
88 is_compatible_iterator<It>::value;
89
90 // SFINAE-compatible wrapper for `std::to_address()`.
91 // Adapted from "base/types/to_address.h" in chromium.
92 template <typename U>
93 requires(!std::is_function_v<U>)
94 [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
95 return p;
96 }
97
98 template <typename It>
99 requires(
100 requires(const It& it) { std::pointer_traits<It>::to_address(it); } ||
101 requires(const It& it) { it.operator->(); })
102 [[nodiscard]] static constexpr auto to_address(const It& it) noexcept {
103 return std::to_address(it);
104 }
105
106 public:
108 constexpr MemorySpan() = default;
109
113 constexpr MemorySpan(std::nullptr_t, size_t) {}
114
116 template <typename Iterator,
117 std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true>
118 constexpr MemorySpan(Iterator first,
119 size_t count) // NOLINT(runtime/explicit)
120 : data_(to_address(first)), size_(count) {}
121
123 template <typename Iterator,
124 std::enable_if_t<is_compatible_iterator_v<Iterator> &&
125 !std::is_convertible_v<Iterator, size_t>,
126 bool> = true>
127 constexpr MemorySpan(Iterator first,
128 Iterator last) // NOLINT(runtime/explicit)
129 : data_(to_address(first)), size_(last - first) {}
130
132 template <size_t N>
133 constexpr MemorySpan(T (&a)[N]) noexcept // NOLINT(runtime/explicit)
134 : data_(a), size_(N) {}
135
137 template <typename U, size_t N,
138 std::enable_if_t<is_array_convertible_v<U, T>, bool> = true>
139 constexpr MemorySpan(
140 std::array<U, N>& a) noexcept // NOLINT(runtime/explicit)
141 : data_(a.data()), size_{N} {}
142
144 template <typename U, size_t N,
145 std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true>
146 constexpr MemorySpan(
147 const std::array<U, N>& a) noexcept // NOLINT(runtime/explicit)
148 : data_(a.data()), size_{N} {}
149
151 [[nodiscard]] constexpr T* data() const { return data_; }
153 [[nodiscard]] constexpr size_t size() const { return size_; }
154
155 [[nodiscard]] constexpr T& operator[](size_t i) const { return data_[i]; }
156
158 [[nodiscard]] constexpr bool empty() const { return size() == 0; }
159
160 class Iterator {
161 public:
162 using difference_type = std::ptrdiff_t;
163 using value_type = T;
166 using iterator_category = std::random_access_iterator_tag;
167 // There seems to be no feature-test macro covering this, so use the
168 // presence of `<ranges>` as a crude proxy, since it was added to the
169 // standard as part of the Ranges papers.
170 // TODO(pkasting): Add this unconditionally after dropping support for old
171 // libstdc++ versions.
172#if __has_include(<ranges>)
173 using iterator_concept = std::contiguous_iterator_tag;
174#endif
175
176 // Required to satisfy `std::semiregular<>`.
177 constexpr Iterator() = default;
178
179 [[nodiscard]] friend constexpr bool operator==(const Iterator& a,
180 const Iterator& b) {
181 // TODO(pkasting): Replace this body with `= default` after dropping
182 // support for old gcc versions.
183 return a.ptr_ == b.ptr_;
184 }
185#if V8_HAVE_SPACESHIP_OPERATOR
186 [[nodiscard]] friend constexpr auto operator<=>(const Iterator&,
187 const Iterator&) = default;
188#else
189 // Assume that if spaceship isn't present, operator rewriting might not be
190 // either.
191 [[nodiscard]] friend constexpr bool operator!=(const Iterator& a,
192 const Iterator& b) {
193 return a.ptr_ != b.ptr_;
194 }
195
196 [[nodiscard]] friend constexpr bool operator<(const Iterator& a,
197 const Iterator& b) {
198 return a.ptr_ < b.ptr_;
199 }
200 [[nodiscard]] friend constexpr bool operator<=(const Iterator& a,
201 const Iterator& b) {
202 return a.ptr_ <= b.ptr_;
203 }
204 [[nodiscard]] friend constexpr bool operator>(const Iterator& a,
205 const Iterator& b) {
206 return a.ptr_ > b.ptr_;
207 }
208 [[nodiscard]] friend constexpr bool operator>=(const Iterator& a,
209 const Iterator& b) {
210 return a.ptr_ >= b.ptr_;
211 }
212#endif
213
214 constexpr Iterator& operator++() {
215 ++ptr_;
216 return *this;
217 }
218
219 constexpr Iterator operator++(int) {
220 Iterator temp = *this;
221 ++*this;
222 return temp;
223 }
224
225 constexpr Iterator& operator--() {
226 --ptr_;
227 return *this;
228 }
229
230 constexpr Iterator operator--(int) {
231 Iterator temp = *this;
232 --*this;
233 return temp;
234 }
235
237 ptr_ += rhs;
238 return *this;
239 }
240
241 [[nodiscard]] friend constexpr Iterator operator+(Iterator lhs,
242 difference_type rhs) {
243 lhs += rhs;
244 return lhs;
245 }
246
247 [[nodiscard]] friend constexpr Iterator operator+(difference_type lhs,
248 const Iterator& rhs) {
249 return rhs + lhs;
250 }
251
253 ptr_ -= rhs;
254 return *this;
255 }
256
257 [[nodiscard]] friend constexpr Iterator operator-(Iterator lhs,
258 difference_type rhs) {
259 lhs -= rhs;
260 return lhs;
261 }
262
263 [[nodiscard]] friend constexpr difference_type operator-(
264 const Iterator& lhs, const Iterator& rhs) {
265 return lhs.ptr_ - rhs.ptr_;
266 }
267
268 [[nodiscard]] constexpr reference operator*() const { return *ptr_; }
269 [[nodiscard]] constexpr pointer operator->() const { return ptr_; }
270 [[nodiscard]] constexpr reference operator[](size_t offset) const {
271 return ptr_[offset];
272 }
273
274 private:
275 friend class MemorySpan<T>;
276
277 constexpr explicit Iterator(T* ptr) : ptr_(ptr) {}
278
279 T* ptr_ = nullptr;
280 };
281
282 [[nodiscard]] Iterator begin() const { return Iterator(data_); }
283 [[nodiscard]] Iterator end() const { return Iterator(data_ + size_); }
284
285 private:
286 T* data_ = nullptr;
287 size_t size_ = 0;
288};
289
301namespace detail {
302template <class T, std::size_t N, std::size_t... I>
303[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
304 T (&a)[N], std::index_sequence<I...>) {
305 return {{a[I]...}};
306}
307
308template <class T, std::size_t N, std::size_t... I>
309[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
310 T (&&a)[N], std::index_sequence<I...>) {
311 return {{std::move(a[I])...}};
312}
313} // namespace detail
314
315template <class T, std::size_t N>
316[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
317 return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
318}
319
320template <class T, std::size_t N>
321[[nodiscard]] constexpr std::array<std::remove_cv_t<T>, N> to_array(
322 T (&&a)[N]) {
323 return detail::to_array_rvalue_impl(std::move(a),
324 std::make_index_sequence<N>{});
325}
326
327} // namespace v8
328#endif // INCLUDE_V8_MEMORY_SPAN_H_
Definition: v8-memory-span.h:160
std::ptrdiff_t difference_type
Definition: v8-memory-span.h:162
friend constexpr bool operator>(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:204
friend constexpr difference_type operator-(const Iterator &lhs, const Iterator &rhs)
Definition: v8-memory-span.h:263
constexpr Iterator & operator+=(difference_type rhs)
Definition: v8-memory-span.h:236
friend constexpr Iterator operator+(Iterator lhs, difference_type rhs)
Definition: v8-memory-span.h:241
constexpr Iterator & operator++()
Definition: v8-memory-span.h:214
friend constexpr bool operator>=(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:208
friend constexpr bool operator==(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:179
std::random_access_iterator_tag iterator_category
Definition: v8-memory-span.h:166
T value_type
Definition: v8-memory-span.h:163
constexpr Iterator()=default
friend constexpr bool operator!=(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:191
value_type & reference
Definition: v8-memory-span.h:165
constexpr reference operator*() const
Definition: v8-memory-span.h:268
friend constexpr Iterator operator+(difference_type lhs, const Iterator &rhs)
Definition: v8-memory-span.h:247
constexpr Iterator operator--(int)
Definition: v8-memory-span.h:230
constexpr Iterator operator++(int)
Definition: v8-memory-span.h:219
value_type * pointer
Definition: v8-memory-span.h:164
friend constexpr bool operator<(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:196
constexpr Iterator & operator-=(difference_type rhs)
Definition: v8-memory-span.h:252
friend constexpr Iterator operator-(Iterator lhs, difference_type rhs)
Definition: v8-memory-span.h:257
friend constexpr bool operator<=(const Iterator &a, const Iterator &b)
Definition: v8-memory-span.h:200
constexpr Iterator & operator--()
Definition: v8-memory-span.h:225
constexpr pointer operator->() const
Definition: v8-memory-span.h:269
Definition: v8-memory-span.h:64
constexpr MemorySpan(std::nullptr_t, size_t)
Definition: v8-memory-span.h:113
Iterator end() const
Definition: v8-memory-span.h:283
constexpr MemorySpan(std::array< U, N > &a) noexcept
Definition: v8-memory-span.h:139
constexpr MemorySpan()=default
constexpr T & operator[](size_t i) const
Definition: v8-memory-span.h:155
constexpr MemorySpan(const std::array< U, N > &a) noexcept
Definition: v8-memory-span.h:146
constexpr MemorySpan(Iterator first, size_t count)
Definition: v8-memory-span.h:118
constexpr MemorySpan(T(&a)[N]) noexcept
Definition: v8-memory-span.h:133
constexpr T * data() const
Definition: v8-memory-span.h:151
constexpr MemorySpan(Iterator first, Iterator last)
Definition: v8-memory-span.h:127
constexpr bool empty() const
Definition: v8-memory-span.h:158
Iterator begin() const
Definition: v8-memory-span.h:282
constexpr size_t size() const
Definition: v8-memory-span.h:153
constexpr std::array< std::remove_cv_t< T >, N > to_array_rvalue_impl(T(&&a)[N], std::index_sequence< I... >)
Definition: v8-memory-span.h:309
constexpr std::array< std::remove_cv_t< T >, N > to_array_lvalue_impl(T(&a)[N], std::index_sequence< I... >)
Definition: v8-memory-span.h:303
Definition: libplatform.h:15
constexpr std::array< std::remove_cv_t< T >, N > to_array(T(&a)[N])
Definition: v8-memory-span.h:316
#define V8_EXPORT
Definition: v8config.h:849