Gecko [ tanishkshah.com ]

Name	Size	Permission	Date
cppgc	[ DIR ]	drwxr-xr-x	2026-09-04 11:57
libplatform	[ DIR ]	drwxr-xr-x	2026-09-04 11:57
uv	[ DIR ]	drwxr-xr-x	2026-09-04 11:57
common.gypi	28.72 KB	-rw-r--r--	2026-08-10 10:34
config.gypi	20.71 KB	-rw-r--r--	2026-08-10 10:35
js_native_api.h	32.38 KB	-rw-r--r--	2026-08-10 10:35
js_native_api_types.h	8.14 KB	-rw-r--r--	2026-08-10 10:35
node.h	71.06 KB	-rw-r--r--	2026-08-10 10:35
node_api.h	10.13 KB	-rw-r--r--	2026-08-10 10:35
node_api_types.h	1.88 KB	-rw-r--r--	2026-08-10 10:35
node_buffer.h	3.6 KB	-rw-r--r--	2026-08-10 10:35
node_object_wrap.h	4.2 KB	-rw-r--r--	2026-08-10 10:35
node_version.h	4.14 KB	-rw-r--r--	2026-08-10 10:35
uv.h	71.33 KB	-rw-r--r--	2026-08-10 10:35
v8-array-buffer.h	22.63 KB	-rw-r--r--	2026-08-10 10:35
v8-callbacks.h	19.32 KB	-rw-r--r--	2026-08-10 10:35
v8-container.h	5.82 KB	-rw-r--r--	2026-08-10 10:35
v8-context.h	21.81 KB	-rw-r--r--	2026-08-10 10:35
v8-cppgc.h	5.83 KB	-rw-r--r--	2026-08-10 10:35
v8-data.h	1.88 KB	-rw-r--r--	2026-08-10 10:35
v8-date.h	1.41 KB	-rw-r--r--	2026-08-10 10:35
v8-debug.h	6.6 KB	-rw-r--r--	2026-08-10 10:35
v8-embedder-heap.h	1.62 KB	-rw-r--r--	2026-08-10 10:35
v8-embedder-state-scope.h	1.46 KB	-rw-r--r--	2026-08-10 10:35
v8-exception.h	9.6 KB	-rw-r--r--	2026-08-10 10:35
v8-extension.h	1.7 KB	-rw-r--r--	2026-08-10 10:35
v8-external.h	2.31 KB	-rw-r--r--	2026-08-10 10:35
v8-forward.h	1.65 KB	-rw-r--r--	2026-08-10 10:35
v8-function-callback.h	22.39 KB	-rw-r--r--	2026-08-10 10:35
v8-function.h	4.75 KB	-rw-r--r--	2026-08-10 10:35
v8-handle-base.h	4.81 KB	-rw-r--r--	2026-08-10 10:35
v8-initialization.h	12.38 KB	-rw-r--r--	2026-08-10 10:35
v8-internal.h	73.55 KB	-rw-r--r--	2026-08-10 10:35
v8-isolate.h	68.41 KB	-rw-r--r--	2026-08-10 10:35
v8-json.h	1.66 KB	-rw-r--r--	2026-08-10 10:35
v8-local-handle.h	27.8 KB	-rw-r--r--	2026-08-10 10:35
v8-locker.h	3.86 KB	-rw-r--r--	2026-08-10 10:35
v8-maybe.h	5.26 KB	-rw-r--r--	2026-08-10 10:35
v8-memory-span.h	8.66 KB	-rw-r--r--	2026-08-10 10:35
v8-message.h	6.43 KB	-rw-r--r--	2026-08-10 10:35
v8-microtask-queue.h	4.79 KB	-rw-r--r--	2026-08-10 10:35
v8-microtask.h	861 B	-rw-r--r--	2026-08-10 10:35
v8-object.h	43.08 KB	-rw-r--r--	2026-08-10 10:35
v8-persistent-handle.h	17.07 KB	-rw-r--r--	2026-08-10 10:35
v8-platform.h	55.4 KB	-rw-r--r--	2026-08-10 10:35
v8-primitive-object.h	2.53 KB	-rw-r--r--	2026-08-10 10:35
v8-primitive.h	35.3 KB	-rw-r--r--	2026-08-10 10:35
v8-profiler.h	46 KB	-rw-r--r--	2026-08-10 10:35
v8-promise.h	5.72 KB	-rw-r--r--	2026-08-10 10:35
v8-proxy.h	1.22 KB	-rw-r--r--	2026-08-10 10:35
v8-regexp.h	3.1 KB	-rw-r--r--	2026-08-10 10:35
v8-sandbox.h	7.23 KB	-rw-r--r--	2026-08-10 10:35
v8-script.h	33.74 KB	-rw-r--r--	2026-08-10 10:35
v8-snapshot.h	11.6 KB	-rw-r--r--	2026-08-10 10:35
v8-source-location.h	2.31 KB	-rw-r--r--	2026-08-10 10:35
v8-statistics.h	7.73 KB	-rw-r--r--	2026-08-10 10:35
v8-template.h	39.18 KB	-rw-r--r--	2026-08-10 10:35
v8-traced-handle.h	12.01 KB	-rw-r--r--	2026-08-10 10:35
v8-typed-array.h	11.16 KB	-rw-r--r--	2026-08-10 10:35
v8-unwinder.h	5.09 KB	-rw-r--r--	2026-08-10 10:35
v8-value-serializer.h	10.56 KB	-rw-r--r--	2026-08-10 10:35
v8-value.h	17.22 KB	-rw-r--r--	2026-08-10 10:35
v8-version.h	773 B	-rw-r--r--	2026-08-10 10:35
v8-wasm.h	10.38 KB	-rw-r--r--	2026-08-10 10:35
v8-weak-callback-info.h	2.72 KB	-rw-r--r--	2026-08-10 10:35
v8.h	3.69 KB	-rw-r--r--	2026-08-10 10:35
v8config.h	36.41 KB	-rw-r--r--	2026-08-10 10:35

Rename

// 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.

#ifndef INCLUDE_V8_MEMORY_SPAN_H_
#define INCLUDE_V8_MEMORY_SPAN_H_

#include <stddef.h>

#include <array>
#include <compare>
#include <cstddef>
#include <iterator>
#include <ranges>
#include <type_traits>

#include "v8config.h"  // NOLINT(build/include_directory)

namespace v8 {

template <typename T>
class V8_EXPORT MemorySpan;

}  // namespace v8

// Mark `MemorySpan` as satisfying the `view` and `borrowed_range` concepts.
// This should be done before the definition of `MemorySpan`, so that any
// inlined calls to range functionality use the correct specializations.
template <typename T>
inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
template <typename T>
inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
    true;

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;

// SFINAE-compatible wrapper for `std::to_address()`.
  // Adapted from "base/types/to_address.h" in chromium.
  template <typename U>
    requires(!std::is_function_v<U>)
  [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
    return p;
  }

template <typename It>
    requires(
        requires(const It& it) { std::pointer_traits<It>::to_address(it); } ||
        requires(const It& it) { it.operator->(); })
  [[nodiscard]] static constexpr auto to_address(const It& it) noexcept {
    return std::to_address(it);
  }

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. */
  [[nodiscard]] constexpr T* data() const { return data_; }
  /** Returns the number of elements that the buffer holds. */
  [[nodiscard]] constexpr size_t size() const { return size_; }

[[nodiscard]] constexpr T& operator[](size_t i) const { return data_[i]; }

/** Returns true if the buffer is empty. */
  [[nodiscard]] constexpr bool empty() const { return size() == 0; }

class Iterator {
   public:
    using difference_type = std::ptrdiff_t;
    using value_type = T;
    using pointer = value_type*;
    using reference = value_type&;
    using iterator_category = std::random_access_iterator_tag;
    using iterator_concept = std::contiguous_iterator_tag;

// Required to satisfy `std::semiregular<>`.
    constexpr Iterator() = default;

[[nodiscard]] constexpr bool operator==(const Iterator&) const = default;
    [[nodiscard]] constexpr auto operator<=>(const Iterator&) const = default;

constexpr Iterator& operator++() {
      ++ptr_;
      return *this;
    }

constexpr Iterator operator++(int) {
      Iterator temp = *this;
      ++*this;
      return temp;
    }

constexpr Iterator& operator--() {
      --ptr_;
      return *this;
    }

constexpr Iterator operator--(int) {
      Iterator temp = *this;
      --*this;
      return temp;
    }

constexpr Iterator& operator+=(difference_type rhs) {
      ptr_ += rhs;
      return *this;
    }

[[nodiscard]] friend constexpr Iterator operator+(Iterator lhs,
                                                      difference_type rhs) {
      lhs += rhs;
      return lhs;
    }

[[nodiscard]] friend constexpr Iterator operator+(difference_type lhs,
                                                      const Iterator& rhs) {
      return rhs + lhs;
    }

constexpr Iterator& operator-=(difference_type rhs) {
      ptr_ -= rhs;
      return *this;
    }

[[nodiscard]] friend constexpr Iterator operator-(Iterator lhs,
                                                      difference_type rhs) {
      lhs -= rhs;
      return lhs;
    }

[[nodiscard]] friend constexpr difference_type operator-(
        const Iterator& lhs, const Iterator& rhs) {
      return lhs.ptr_ - rhs.ptr_;
    }

[[nodiscard]] constexpr reference operator*() const { return *ptr_; }
    [[nodiscard]] constexpr pointer operator->() const { return ptr_; }
    [[nodiscard]] constexpr reference operator[](size_t offset) const {
      return ptr_[offset];
    }

private:
    friend class MemorySpan<T>;

constexpr explicit Iterator(T* ptr) : ptr_(ptr) {}

T* ptr_ = nullptr;
  };

[[nodiscard]] Iterator begin() const { return Iterator(data_); }
  [[nodiscard]] 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>
[[nodiscard]] 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>
[[nodiscard]] 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>
[[nodiscard]] 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>
[[nodiscard]] 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
#endif  // INCLUDE_V8_MEMORY_SPAN_H_