v8-memory-span.h

Go to the documentation of this file.

// 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 <iterator>
#include <type_traits>
 
#include "v8config.h"  // NOLINT(build/include_directory)
 
namespace v8 {
 
template <typename T>
class V8_EXPORT MemorySpan {
 private:
  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:
  constexpr MemorySpan() = default;
 
  constexpr MemorySpan(std::nullptr_t, size_t) {}
 
  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) {}
 
  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) {}
 
  template <size_t N>
  constexpr MemorySpan(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
      : data_(a), size_(N) {}
 
  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} {}
 
  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} {}
 
  constexpr T* data() const { return data_; }
  constexpr size_t size() const { return size_; }
 
  constexpr T& operator[](size_t i) const { return data_[i]; }
 
  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;
};
 
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
#endif  // INCLUDE_V8_MEMORY_SPAN_H_