Download tools/node-v22.19.0-linux-x64/include/node/v8-memory-span.h from SitongGong/gst-code-collection: direct link, hf CLI and curl.
- Browser
- Download file 6.42 kB
-
https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/tools/node-v22.19.0-linux-x64/include/node/v8-memory-span.h
- Command line
-
hf download hf://datasets/SitongGong/gst-code-collection/tools/node-v22.19.0-linux-x64/include/node/v8-memory-span.h
-
curl -L -o v8-memory-span.h https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/tools/node-v22.19.0-linux-x64/include/node/v8-memory-span.h
6.42 kB
| // Copyright 2021 the V8 project authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| namespace v8 { | |
| /** | |
| * Points to an unowned contiguous buffer holding a known number of elements. | |
| * | |
| * This is similar to std::span (under consideration for C++20), but does not | |
| * require advanced C++ support. In the (far) future, this may be replaced with | |
| * or aliased to std::span. | |
| * | |
| * To facilitate future migration, this class exposes a subset of the interface | |
| * implemented by std::span. | |
| */ | |
| template <typename T> | |
| class V8_EXPORT MemorySpan { | |
| private: | |
| /** Some C++ machinery, brought from the future. */ | |
| template <typename From, typename To> | |
| using is_array_convertible = std::is_convertible<From (*)[], To (*)[]>; | |
| template <typename From, typename To> | |
| static constexpr bool is_array_convertible_v = | |
| is_array_convertible<From, To>::value; | |
| template <typename It> | |
| using iter_reference_t = decltype(*std::declval<It&>()); | |
| template <typename It, typename = void> | |
| struct is_compatible_iterator : std::false_type {}; | |
| template <typename It> | |
| struct is_compatible_iterator< | |
| It, | |
| std::void_t< | |
| std::is_base_of<std::random_access_iterator_tag, | |
| typename std::iterator_traits<It>::iterator_category>, | |
| is_array_convertible<std::remove_reference_t<iter_reference_t<It>>, | |
| T>>> : std::true_type {}; | |
| template <typename It> | |
| static constexpr bool is_compatible_iterator_v = | |
| is_compatible_iterator<It>::value; | |
| template <typename U> | |
| static constexpr U* to_address(U* p) noexcept { | |
| return p; | |
| } | |
| template <typename It, | |
| typename = std::void_t<decltype(std::declval<It&>().operator->())>> | |
| static constexpr auto to_address(It it) noexcept { | |
| return it.operator->(); | |
| } | |
| public: | |
| /** The default constructor creates an empty span. */ | |
| constexpr MemorySpan() = default; | |
| /** Constructor from nullptr and count, for backwards compatibility. | |
| * This is not compatible with C++20 std::span. | |
| */ | |
| constexpr MemorySpan(std::nullptr_t, size_t) {} | |
| /** Constructor from "iterator" and count. */ | |
| template <typename Iterator, | |
| std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true> | |
| constexpr MemorySpan(Iterator first, | |
| size_t count) // NOLINT(runtime/explicit) | |
| : data_(to_address(first)), size_(count) {} | |
| /** Constructor from two "iterators". */ | |
| template <typename Iterator, | |
| std::enable_if_t<is_compatible_iterator_v<Iterator> && | |
| !std::is_convertible_v<Iterator, size_t>, | |
| bool> = true> | |
| constexpr MemorySpan(Iterator first, | |
| Iterator last) // NOLINT(runtime/explicit) | |
| : data_(to_address(first)), size_(last - first) {} | |
| /** Implicit conversion from C-style array. */ | |
| template <size_t N> | |
| constexpr MemorySpan(T (&a)[N]) noexcept // NOLINT(runtime/explicit) | |
| : data_(a), size_(N) {} | |
| /** Implicit conversion from std::array. */ | |
| template <typename U, size_t N, | |
| std::enable_if_t<is_array_convertible_v<U, T>, bool> = true> | |
| constexpr MemorySpan( | |
| std::array<U, N>& a) noexcept // NOLINT(runtime/explicit) | |
| : data_(a.data()), size_{N} {} | |
| /** Implicit conversion from const std::array. */ | |
| template <typename U, size_t N, | |
| std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true> | |
| constexpr MemorySpan( | |
| const std::array<U, N>& a) noexcept // NOLINT(runtime/explicit) | |
| : data_(a.data()), size_{N} {} | |
| /** Returns a pointer to the beginning of the buffer. */ | |
| constexpr T* data() const { return data_; } | |
| /** Returns the number of elements that the buffer holds. */ | |
| constexpr size_t size() const { return size_; } | |
| constexpr T& operator[](size_t i) const { return data_[i]; } | |
| /** Returns true if the buffer is empty. */ | |
| constexpr bool empty() const { return size() == 0; } | |
| class Iterator { | |
| public: | |
| using iterator_category = std::forward_iterator_tag; | |
| using value_type = T; | |
| using difference_type = std::ptrdiff_t; | |
| using pointer = value_type*; | |
| using reference = value_type&; | |
| T& operator*() const { return *ptr_; } | |
| T* operator->() const { return ptr_; } | |
| bool operator==(Iterator other) const { return ptr_ == other.ptr_; } | |
| bool operator!=(Iterator other) const { return !(*this == other); } | |
| Iterator& operator++() { | |
| ++ptr_; | |
| return *this; | |
| } | |
| Iterator operator++(int) { | |
| Iterator temp(*this); | |
| ++(*this); | |
| return temp; | |
| } | |
| private: | |
| friend class MemorySpan<T>; | |
| explicit Iterator(T* ptr) : ptr_(ptr) {} | |
| T* ptr_ = nullptr; | |
| }; | |
| Iterator begin() const { return Iterator(data_); } | |
| Iterator end() const { return Iterator(data_ + size_); } | |
| private: | |
| T* data_ = nullptr; | |
| size_t size_ = 0; | |
| }; | |
| /** | |
| * Helper function template to create an array of fixed length, initialized by | |
| * the provided initializer list, without explicitly specifying the array size, | |
| * e.g. | |
| * | |
| * auto arr = v8::to_array<Local<String>>({v8_str("one"), v8_str("two")}); | |
| * | |
| * In the future, this may be replaced with or aliased to std::to_array (under | |
| * consideration for C++20). | |
| */ | |
| namespace detail { | |
| template <class T, std::size_t N, std::size_t... I> | |
| constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl( | |
| T (&a)[N], std::index_sequence<I...>) { | |
| return {{a[I]...}}; | |
| } | |
| template <class T, std::size_t N, std::size_t... I> | |
| constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl( | |
| T (&&a)[N], std::index_sequence<I...>) { | |
| return {{std::move(a[I])...}}; | |
| } | |
| } // namespace detail | |
| template <class T, std::size_t N> | |
| constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) { | |
| return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{}); | |
| } | |
| template <class T, std::size_t N> | |
| constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) { | |
| return detail::to_array_rvalue_impl(std::move(a), | |
| std::make_index_sequence<N>{}); | |
| } | |
| } // namespace v8 | |