@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.12

package/pods/Headers/include/cppgc/member.h

@@ -1,291 +0,0 @@
-// Copyright 2020 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_CPPGC_MEMBER_H_
-#define INCLUDE_CPPGC_MEMBER_H_
-
-#include <atomic>
-#include <cstddef>
-#include <type_traits>
-
-#include "cppgc/internal/pointer-policies.h"
-#include "cppgc/sentinel-pointer.h"
-#include "cppgc/type-traits.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class Visitor;
-
-namespace internal {
-
-// MemberBase always refers to the object as const object and defers to
-// BasicMember on casting to the right type as needed.
-class MemberBase {
- protected:
-  struct AtomicInitializerTag {};
-
-  MemberBase() : raw_(nullptr) {}
-  explicit MemberBase(const void* value) : raw_(value) {}
-  MemberBase(const void* value, AtomicInitializerTag) { SetRawAtomic(value); }
-
-  const void** GetRawSlot() const { return &raw_; }
-  const void* GetRaw() const { return raw_; }
-  void SetRaw(void* value) { raw_ = value; }
-
-  const void* GetRawAtomic() const {
-    return reinterpret_cast<const std::atomic<const void*>*>(&raw_)->load(
-        std::memory_order_relaxed);
-  }
-  void SetRawAtomic(const void* value) {
-    reinterpret_cast<std::atomic<const void*>*>(&raw_)->store(
-        value, std::memory_order_relaxed);
-  }
-
-  void ClearFromGC() const { raw_ = nullptr; }
-
- private:
-  // All constructors initialize `raw_`. Do not add a default value here as it
-  // results in a non-atomic write on some builds, even when the atomic version
-  // of the constructor is used.
-  mutable const void* raw_;
-};
-
-// The basic class from which all Member classes are 'generated'.
-template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy>
-class BasicMember final : private MemberBase, private CheckingPolicy {
- public:
-  using PointeeType = T;
-
-  constexpr BasicMember() = default;
-  constexpr BasicMember(std::nullptr_t) {}     // NOLINT
-  BasicMember(SentinelPointer s) : MemberBase(s) {}  // NOLINT
-  BasicMember(T* raw) : MemberBase(raw) {            // NOLINT
-    InitializingWriteBarrier();
-    this->CheckPointer(Get());
-  }
-  BasicMember(T& raw) : BasicMember(&raw) {}  // NOLINT
-  // Atomic ctor. Using the AtomicInitializerTag forces BasicMember to
-  // initialize using atomic assignments. This is required for preventing
-  // data races with concurrent marking.
-  using AtomicInitializerTag = MemberBase::AtomicInitializerTag;
-  BasicMember(std::nullptr_t, AtomicInitializerTag atomic)
-      : MemberBase(nullptr, atomic) {}
-  BasicMember(SentinelPointer s, AtomicInitializerTag atomic)
-      : MemberBase(s, atomic) {}
-  BasicMember(T* raw, AtomicInitializerTag atomic) : MemberBase(raw, atomic) {
-    InitializingWriteBarrier();
-    this->CheckPointer(Get());
-  }
-  BasicMember(T& raw, AtomicInitializerTag atomic)
-      : BasicMember(&raw, atomic) {}
-  // Copy ctor.
-  BasicMember(const BasicMember& other) : BasicMember(other.Get()) {}
-  // Allow heterogeneous construction.
-  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(  // NOLINT
-      const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                        OtherCheckingPolicy>& other)
-      : BasicMember(other.Get()) {}
-  // Move ctor.
-  BasicMember(BasicMember&& other) noexcept : BasicMember(other.Get()) {
-    other.Clear();
-  }
-  // Allow heterogeneous move construction.
-  template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                          OtherCheckingPolicy>&& other) noexcept
-      : BasicMember(other.Get()) {
-    other.Clear();
-  }
-  // Construction from Persistent.
-  template <typename U, typename PersistentWeaknessPolicy,
-            typename PersistentLocationPolicy,
-            typename PersistentCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember(const BasicPersistent<U, PersistentWeaknessPolicy,
-                                    PersistentLocationPolicy,
-                                    PersistentCheckingPolicy>& p)
-      : BasicMember(p.Get()) {}
-
-  // Copy assignment.
-  BasicMember& operator=(const BasicMember& other) {
-    return operator=(other.Get());
-  }
-  // Allow heterogeneous copy assignment.
-  template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
-      const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                        OtherCheckingPolicy>& other) {
-    return operator=(other.Get());
-  }
-  // Move assignment.
-  BasicMember& operator=(BasicMember&& other) noexcept {
-    operator=(other.Get());
-    other.Clear();
-    return *this;
-  }
-  // Heterogeneous move assignment.
-  template <typename U, typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
-                                     OtherCheckingPolicy>&& other) noexcept {
-    operator=(other.Get());
-    other.Clear();
-    return *this;
-  }
-  // Assignment from Persistent.
-  template <typename U, typename PersistentWeaknessPolicy,
-            typename PersistentLocationPolicy,
-            typename PersistentCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicMember& operator=(
-      const BasicPersistent<U, PersistentWeaknessPolicy,
-                            PersistentLocationPolicy, PersistentCheckingPolicy>&
-          other) {
-    return operator=(other.Get());
-  }
-  BasicMember& operator=(T* other) {
-    SetRawAtomic(other);
-    AssigningWriteBarrier();
-    this->CheckPointer(Get());
-    return *this;
-  }
-  BasicMember& operator=(std::nullptr_t) {
-    Clear();
-    return *this;
-  }
-  BasicMember& operator=(SentinelPointer s) {
-    SetRawAtomic(s);
-    return *this;
-  }
-
-  template <typename OtherWeaknessTag, typename OtherBarrierPolicy,
-            typename OtherCheckingPolicy>
-  void Swap(BasicMember<T, OtherWeaknessTag, OtherBarrierPolicy,
-                        OtherCheckingPolicy>& other) {
-    T* tmp = Get();
-    *this = other;
-    other = tmp;
-  }
-
-  explicit operator bool() const { return Get(); }
-  operator T*() const { return Get(); }
-  T* operator->() const { return Get(); }
-  T& operator*() const { return *Get(); }
-
-  // CFI cast exemption to allow passing SentinelPointer through T* and support
-  // heterogeneous assignments between different Member and Persistent handles
-  // based on their actual types.
-  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
-    // Executed by the mutator, hence non atomic load.
-    //
-    // The const_cast below removes the constness from MemberBase storage. The
-    // following static_cast re-adds any constness if specified through the
-    // user-visible template parameter T.
-    return static_cast<T*>(const_cast<void*>(MemberBase::GetRaw()));
-  }
-
-  void Clear() { SetRawAtomic(nullptr); }
-
-  T* Release() {
-    T* result = Get();
-    Clear();
-    return result;
-  }
-
-  const T** GetSlotForTesting() const {
-    return reinterpret_cast<const T**>(GetRawSlot());
-  }
-
- private:
-  const T* GetRawAtomic() const {
-    return static_cast<const T*>(MemberBase::GetRawAtomic());
-  }
-
-  void InitializingWriteBarrier() const {
-    WriteBarrierPolicy::InitializingBarrier(GetRawSlot(), GetRaw());
-  }
-  void AssigningWriteBarrier() const {
-    WriteBarrierPolicy::AssigningBarrier(GetRawSlot(), GetRaw());
-  }
-
-  void ClearFromGC() const { MemberBase::ClearFromGC(); }
-
-  T* GetFromGC() const { return Get(); }
-
-  friend class cppgc::Visitor;
-  template <typename U>
-  friend struct cppgc::TraceTrait;
-};
-
-template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
-          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
-          typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator==(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
-  return member1.Get() == member2.Get();
-}
-
-template <typename T1, typename WeaknessTag1, typename WriteBarrierPolicy1,
-          typename CheckingPolicy1, typename T2, typename WeaknessTag2,
-          typename WriteBarrierPolicy2, typename CheckingPolicy2>
-bool operator!=(const BasicMember<T1, WeaknessTag1, WriteBarrierPolicy1,
-                                  CheckingPolicy1>& member1,
-                const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2,
-                                  CheckingPolicy2>& member2) {
-  return !(member1 == member2);
-}
-
-template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy>
-struct IsWeak<
-    internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy>>
-    : std::true_type {};
-
-}  // namespace internal
-
-/**
- * Members are used in classes to contain strong pointers to other garbage
- * collected objects. All Member fields of a class must be traced in the class'
- * trace method.
- */
-template <typename T>
-using Member = internal::BasicMember<T, internal::StrongMemberTag,
-                                     internal::DijkstraWriteBarrierPolicy>;
-
-/**
- * WeakMember is similar to Member in that it is used to point to other garbage
- * collected objects. However instead of creating a strong pointer to the
- * object, the WeakMember creates a weak pointer, which does not keep the
- * pointee alive. Hence if all pointers to to a heap allocated object are weak
- * the object will be garbage collected. At the time of GC the weak pointers
- * will automatically be set to null.
- */
-template <typename T>
-using WeakMember = internal::BasicMember<T, internal::WeakMemberTag,
-                                         internal::DijkstraWriteBarrierPolicy>;
-
-/**
- * UntracedMember is a pointer to an on-heap object that is not traced for some
- * reason. Do not use this unless you know what you are doing. Keeping raw
- * pointers to on-heap objects is prohibited unless used from stack. Pointee
- * must be kept alive through other means.
- */
-template <typename T>
-using UntracedMember = internal::BasicMember<T, internal::UntracedMemberTag,
-                                             internal::NoWriteBarrierPolicy>;
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_MEMBER_H_

package/pods/Headers/include/cppgc/name-provider.h

@@ -1,65 +0,0 @@
-// Copyright 2020 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_CPPGC_NAME_PROVIDER_H_
-#define INCLUDE_CPPGC_NAME_PROVIDER_H_
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-/**
- * NameProvider allows for providing a human-readable name for garbage-collected
- * objects.
- *
- * There's two cases of names to distinguish:
- * a. Explicitly specified names via using NameProvider. Such names are always
- *    preserved in the system.
- * b. Internal names that Oilpan infers from a C++ type on the class hierarchy
- *    of the object. This is not necessarily the type of the actually
- *    instantiated object.
- *
- * Depending on the build configuration, Oilpan may hide names, i.e., represent
- * them with kHiddenName, of case b. to avoid exposing internal details.
- */
-class V8_EXPORT NameProvider {
- public:
-  /**
-   * Name that is used when hiding internals.
-   */
-  static constexpr const char kHiddenName[] = "InternalNode";
-
-  /**
-   * Name that is used in case compiler support is missing for composing a name
-   * from C++ types.
-   */
-  static constexpr const char kNoNameDeducible[] = "<No name>";
-
-  /**
-   * Indicating whether internal names are hidden or not.
-   *
-   * @returns true if C++ names should be hidden and represented by kHiddenName.
-   */
-  static constexpr bool HideInternalNames() {
-#if CPPGC_SUPPORTS_OBJECT_NAMES
-    return false;
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
-    return true;
-#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
-  }
-
-  virtual ~NameProvider() = default;
-
-  /**
-   * Specifies a name for the garbage-collected object. Such names will never
-   * be hidden, as they are explicitly specified by the user of this API.
-   *
-   * @returns a human readable name for the object.
-   */
-  virtual const char* GetHumanReadableName() const = 0;
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_NAME_PROVIDER_H_

package/pods/Headers/include/cppgc/object-size-trait.h

@@ -1,58 +0,0 @@
-// 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_CPPGC_OBJECT_SIZE_TRAIT_H_
-#define INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_
-
-#include <cstddef>
-
-#include "cppgc/type-traits.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-namespace internal {
-
-struct V8_EXPORT BaseObjectSizeTrait {
- protected:
-  static size_t GetObjectSizeForGarbageCollected(const void*);
-  static size_t GetObjectSizeForGarbageCollectedMixin(const void*);
-};
-
-}  // namespace internal
-
-namespace subtle {
-
-/**
- * Trait specifying how to get the size of an object that was allocated using
- * `MakeGarbageCollected()`. Also supports querying the size with an inner
- * pointer to a mixin.
- */
-template <typename T, bool = IsGarbageCollectedMixinTypeV<T>>
-struct ObjectSizeTrait;
-
-template <typename T>
-struct ObjectSizeTrait<T, false> : cppgc::internal::BaseObjectSizeTrait {
-  static_assert(sizeof(T), "T must be fully defined");
-  static_assert(IsGarbageCollectedTypeV<T>,
-                "T must be of type GarbageCollected or GarbageCollectedMixin");
-
-  static size_t GetSize(const T& object) {
-    return GetObjectSizeForGarbageCollected(&object);
-  }
-};
-
-template <typename T>
-struct ObjectSizeTrait<T, true> : cppgc::internal::BaseObjectSizeTrait {
-  static_assert(sizeof(T), "T must be fully defined");
-
-  static size_t GetSize(const T& object) {
-    return GetObjectSizeForGarbageCollectedMixin(&object);
-  }
-};
-
-}  // namespace subtle
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_OBJECT_SIZE_TRAIT_H_