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

package/pods/Headers/include/cppgc/source-location.h

@@ -1,92 +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_SOURCE_LOCATION_H_
-#define INCLUDE_CPPGC_SOURCE_LOCATION_H_
-
-#include <cstddef>
-#include <string>
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-#if defined(__has_builtin)
-#define CPPGC_SUPPORTS_SOURCE_LOCATION                                   \
-  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
-   __has_builtin(__builtin_LINE))  // NOLINT
-#elif defined(V8_CC_GNU) && __GNUC__ >= 7
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 1
-#elif defined(V8_CC_INTEL) && __ICC >= 1800
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 1
-#else
-#define CPPGC_SUPPORTS_SOURCE_LOCATION 0
-#endif
-
-namespace cppgc {
-
-/**
- * Encapsulates source location information. Mimics C++20's
- * `std::source_location`.
- */
-class V8_EXPORT SourceLocation final {
- public:
-  /**
-   * Construct source location information corresponding to the location of the
-   * call site.
-   */
-#if CPPGC_SUPPORTS_SOURCE_LOCATION
-  static constexpr SourceLocation Current(
-      const char* function = __builtin_FUNCTION(),
-      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
-    return SourceLocation(function, file, line);
-  }
-#else
-  static constexpr SourceLocation Current() { return SourceLocation(); }
-#endif  // CPPGC_SUPPORTS_SOURCE_LOCATION
-
-  /**
-   * Constructs unspecified source location information.
-   */
-  constexpr SourceLocation() = default;
-
-  /**
-   * Returns the name of the function associated with the position represented
-   * by this object, if any.
-   *
-   * \returns the function name as cstring.
-   */
-  constexpr const char* Function() const { return function_; }
-
-  /**
-   * Returns the name of the current source file represented by this object.
-   *
-   * \returns the file name as cstring.
-   */
-  constexpr const char* FileName() const { return file_; }
-
-  /**
-   * Returns the line number represented by this object.
-   *
-   * \returns the line number.
-   */
-  constexpr size_t Line() const { return line_; }
-
-  /**
-   * Returns a human-readable string representing this object.
-   *
-   * \returns a human-readable string representing source location information.
-   */
-  std::string ToString() const;
-
- private:
-  constexpr SourceLocation(const char* function, const char* file, size_t line)
-      : function_(function), file_(file), line_(line) {}
-
-  const char* function_ = nullptr;
-  const char* file_ = nullptr;
-  size_t line_ = 0u;
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_SOURCE_LOCATION_H_

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

@@ -1,106 +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_TESTING_H_
-#define INCLUDE_CPPGC_TESTING_H_
-
-#include "cppgc/common.h"
-#include "cppgc/macros.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class HeapHandle;
-
-/**
- * Namespace contains testing helpers.
- */
-namespace testing {
-
-/**
- * Overrides the state of the stack with the provided value. Parameters passed
- * to explicit garbage collection calls still take precedence. Must not be
- * nested.
- *
- * This scope is useful to make the garbage collector consider the stack when
- * tasks that invoke garbage collection (through the provided platform) contain
- * interesting pointers on its stack.
- */
-class V8_EXPORT V8_NODISCARD OverrideEmbedderStackStateScope final {
-  CPPGC_STACK_ALLOCATED();
-
- public:
-  /**
-   * Constructs a scoped object that automatically enters and leaves the scope.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  explicit OverrideEmbedderStackStateScope(HeapHandle& heap_handle,
-                                           EmbedderStackState state);
-  ~OverrideEmbedderStackStateScope();
-
-  OverrideEmbedderStackStateScope(const OverrideEmbedderStackStateScope&) =
-      delete;
-  OverrideEmbedderStackStateScope& operator=(
-      const OverrideEmbedderStackStateScope&) = delete;
-
- private:
-  HeapHandle& heap_handle_;
-};
-
-/**
- * Testing interface for managed heaps that allows for controlling garbage
- * collection timings. Embedders should use this class when testing the
- * interaction of their code with incremental/concurrent garbage collection.
- */
-class V8_EXPORT StandaloneTestingHeap final {
- public:
-  explicit StandaloneTestingHeap(HeapHandle&);
-
-  /**
-   * Start an incremental garbage collection.
-   */
-  void StartGarbageCollection();
-
-  /**
-   * Perform an incremental step. This will also schedule concurrent steps if
-   * needed.
-   *
-   * \param stack_state The state of the stack during the step.
-   */
-  bool PerformMarkingStep(EmbedderStackState stack_state);
-
-  /**
-   * Finalize the current garbage collection cycle atomically.
-   * Assumes that garbage collection is in progress.
-   *
-   * \param stack_state The state of the stack for finalizing the garbage
-   * collection cycle.
-   */
-  void FinalizeGarbageCollection(EmbedderStackState stack_state);
-
-  /**
-   * Toggle main thread marking on/off. Allows to stress concurrent marking
-   * (e.g. to better detect data races).
-   *
-   * \param should_mark Denotes whether the main thread should contribute to
-   * marking. Defaults to true.
-   */
-  void ToggleMainThreadMarking(bool should_mark);
-
-  /**
-   * Force enable compaction for the next garbage collection cycle.
-   */
-  void ForceCompactionForNextGarbageCollection();
-
- private:
-  HeapHandle& heap_handle_;
-};
-
-V8_EXPORT bool IsHeapObjectOld(void*);
-
-}  // namespace testing
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_TESTING_H_

package/pods/Headers/include/cppgc/trace-trait.h

@@ -1,116 +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_TRACE_TRAIT_H_
-#define INCLUDE_CPPGC_TRACE_TRAIT_H_
-
-#include <type_traits>
-
-#include "cppgc/type-traits.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class Visitor;
-
-namespace internal {
-
-// Implementation of the default TraceTrait handling GarbageCollected and
-// GarbageCollectedMixin.
-template <typename T,
-          bool =
-              IsGarbageCollectedMixinTypeV<typename std::remove_const<T>::type>>
-struct TraceTraitImpl;
-
-}  // namespace internal
-
-/**
- * Callback for invoking tracing on a given object.
- *
- * \param visitor The visitor to dispatch to.
- * \param object The object to invoke tracing on.
- */
-using TraceCallback = void (*)(Visitor* visitor, const void* object);
-
-/**
- * Describes how to trace an object, i.e., how to visit all Oilpan-relevant
- * fields of an object.
- */
-struct TraceDescriptor {
-  /**
-   * Adjusted base pointer, i.e., the pointer to the class inheriting directly
-   * from GarbageCollected, of the object that is being traced.
-   */
-  const void* base_object_payload;
-  /**
-   * Callback for tracing the object.
-   */
-  TraceCallback callback;
-};
-
-namespace internal {
-
-struct V8_EXPORT TraceTraitFromInnerAddressImpl {
-  static TraceDescriptor GetTraceDescriptor(const void* address);
-};
-
-/**
- * Trait specifying how the garbage collector processes an object of type T.
- *
- * Advanced users may override handling by creating a specialization for their
- * type.
- */
-template <typename T>
-struct TraceTraitBase {
-  static_assert(internal::IsTraceableV<T>, "T must have a Trace() method");
-
-  /**
-   * Accessor for retrieving a TraceDescriptor to process an object of type T.
-   *
-   * \param self The object to be processed.
-   * \returns a TraceDescriptor to process the object.
-   */
-  static TraceDescriptor GetTraceDescriptor(const void* self) {
-    return internal::TraceTraitImpl<T>::GetTraceDescriptor(
-        static_cast<const T*>(self));
-  }
-
-  /**
-   * Function invoking the tracing for an object of type T.
-   *
-   * \param visitor The visitor to dispatch to.
-   * \param self The object to invoke tracing on.
-   */
-  static void Trace(Visitor* visitor, const void* self) {
-    static_cast<const T*>(self)->Trace(visitor);
-  }
-};
-
-}  // namespace internal
-
-template <typename T>
-struct TraceTrait : public internal::TraceTraitBase<T> {};
-
-namespace internal {
-
-template <typename T>
-struct TraceTraitImpl<T, false> {
-  static_assert(IsGarbageCollectedTypeV<T>,
-                "T must be of type GarbageCollected or GarbageCollectedMixin");
-  static TraceDescriptor GetTraceDescriptor(const void* self) {
-    return {self, TraceTrait<T>::Trace};
-  }
-};
-
-template <typename T>
-struct TraceTraitImpl<T, true> {
-  static TraceDescriptor GetTraceDescriptor(const void* self) {
-    return internal::TraceTraitFromInnerAddressImpl::GetTraceDescriptor(self);
-  }
-};
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_TRACE_TRAIT_H_

package/pods/Headers/include/cppgc/type-traits.h

@@ -1,240 +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_TYPE_TRAITS_H_
-#define INCLUDE_CPPGC_TYPE_TRAITS_H_
-
-// This file should stay with minimal dependencies to allow embedder to check
-// against Oilpan types without including any other parts.
-#include <cstddef>
-#include <type_traits>
-
-namespace cppgc {
-
-class Visitor;
-
-namespace internal {
-template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy>
-class BasicMember;
-struct DijkstraWriteBarrierPolicy;
-struct NoWriteBarrierPolicy;
-class StrongMemberTag;
-class UntracedMemberTag;
-class WeakMemberTag;
-
-// Not supposed to be specialized by the user.
-template <typename T>
-struct IsWeak : std::false_type {};
-
-// IsTraceMethodConst is used to verify that all Trace methods are marked as
-// const. It is equivalent to IsTraceable but for a non-const object.
-template <typename T, typename = void>
-struct IsTraceMethodConst : std::false_type {};
-
-template <typename T>
-struct IsTraceMethodConst<T, std::void_t<decltype(std::declval<const T>().Trace(
-                                 std::declval<Visitor*>()))>> : std::true_type {
-};
-
-template <typename T, typename = void>
-struct IsTraceable : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct IsTraceable<
-    T, std::void_t<decltype(std::declval<T>().Trace(std::declval<Visitor*>()))>>
-    : std::true_type {
-  // All Trace methods should be marked as const. If an object of type
-  // 'T' is traceable then any object of type 'const T' should also
-  // be traceable.
-  static_assert(IsTraceMethodConst<T>(),
-                "Trace methods should be marked as const.");
-};
-
-template <typename T>
-constexpr bool IsTraceableV = IsTraceable<T>::value;
-
-template <typename T, typename = void>
-struct HasGarbageCollectedMixinTypeMarker : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct HasGarbageCollectedMixinTypeMarker<
-    T, std::void_t<
-           typename std::remove_const_t<T>::IsGarbageCollectedMixinTypeMarker>>
-    : std::true_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T, typename = void>
-struct HasGarbageCollectedTypeMarker : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct HasGarbageCollectedTypeMarker<
-    T,
-    std::void_t<typename std::remove_const_t<T>::IsGarbageCollectedTypeMarker>>
-    : std::true_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T, bool = HasGarbageCollectedTypeMarker<T>::value,
-          bool = HasGarbageCollectedMixinTypeMarker<T>::value>
-struct IsGarbageCollectedMixinType : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct IsGarbageCollectedMixinType<T, false, true> : std::true_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T, bool = HasGarbageCollectedTypeMarker<T>::value>
-struct IsGarbageCollectedType : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct IsGarbageCollectedType<T, true> : std::true_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct IsGarbageCollectedOrMixinType
-    : std::integral_constant<bool, IsGarbageCollectedType<T>::value ||
-                                       IsGarbageCollectedMixinType<T>::value> {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T, bool = (HasGarbageCollectedTypeMarker<T>::value &&
-                              HasGarbageCollectedMixinTypeMarker<T>::value)>
-struct IsGarbageCollectedWithMixinType : std::false_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename T>
-struct IsGarbageCollectedWithMixinType<T, true> : std::true_type {
-  static_assert(sizeof(T), "T must be fully defined");
-};
-
-template <typename BasicMemberCandidate, typename WeaknessTag,
-          typename WriteBarrierPolicy>
-struct IsSubclassOfBasicMemberTemplate {
- private:
-  template <typename T, typename CheckingPolicy>
-  static std::true_type SubclassCheck(
-      BasicMember<T, WeaknessTag, WriteBarrierPolicy, CheckingPolicy>*);
-  static std::false_type SubclassCheck(...);
-
- public:
-  static constexpr bool value =
-      decltype(SubclassCheck(std::declval<BasicMemberCandidate*>()))::value;
-};
-
-template <typename T,
-          bool = IsSubclassOfBasicMemberTemplate<
-              T, StrongMemberTag, DijkstraWriteBarrierPolicy>::value>
-struct IsMemberType : std::false_type {};
-
-template <typename T>
-struct IsMemberType<T, true> : std::true_type {};
-
-template <typename T, bool = IsSubclassOfBasicMemberTemplate<
-                          T, WeakMemberTag, DijkstraWriteBarrierPolicy>::value>
-struct IsWeakMemberType : std::false_type {};
-
-template <typename T>
-struct IsWeakMemberType<T, true> : std::true_type {};
-
-template <typename T, bool = IsSubclassOfBasicMemberTemplate<
-                          T, UntracedMemberTag, NoWriteBarrierPolicy>::value>
-struct IsUntracedMemberType : std::false_type {};
-
-template <typename T>
-struct IsUntracedMemberType<T, true> : std::true_type {};
-
-template <typename T>
-struct IsComplete {
- private:
-  template <typename U, size_t = sizeof(U)>
-  static std::true_type IsSizeOfKnown(U*);
-  static std::false_type IsSizeOfKnown(...);
-
- public:
-  static constexpr bool value =
-      decltype(IsSizeOfKnown(std::declval<T*>()))::value;
-};
-
-}  // namespace internal
-
-/**
- * Value is true for types that inherit from `GarbageCollectedMixin` but not
- * `GarbageCollected<T>` (i.e., they are free mixins), and false otherwise.
- */
-template <typename T>
-constexpr bool IsGarbageCollectedMixinTypeV =
-    internal::IsGarbageCollectedMixinType<T>::value;
-
-/**
- * Value is true for types that inherit from `GarbageCollected<T>`, and false
- * otherwise.
- */
-template <typename T>
-constexpr bool IsGarbageCollectedTypeV =
-    internal::IsGarbageCollectedType<T>::value;
-
-/**
- * Value is true for types that inherit from either `GarbageCollected<T>` or
- * `GarbageCollectedMixin`, and false otherwise.
- */
-template <typename T>
-constexpr bool IsGarbageCollectedOrMixinTypeV =
-    internal::IsGarbageCollectedOrMixinType<T>::value;
-
-/**
- * Value is true for types that inherit from `GarbageCollected<T>` and
- * `GarbageCollectedMixin`, and false otherwise.
- */
-template <typename T>
-constexpr bool IsGarbageCollectedWithMixinTypeV =
-    internal::IsGarbageCollectedWithMixinType<T>::value;
-
-/**
- * Value is true for types of type `Member<T>`, and false otherwise.
- */
-template <typename T>
-constexpr bool IsMemberTypeV = internal::IsMemberType<T>::value;
-
-/**
- * Value is true for types of type `UntracedMember<T>`, and false otherwise.
- */
-template <typename T>
-constexpr bool IsUntracedMemberTypeV = internal::IsUntracedMemberType<T>::value;
-
-/**
- * Value is true for types of type `WeakMember<T>`, and false otherwise.
- */
-template <typename T>
-constexpr bool IsWeakMemberTypeV = internal::IsWeakMemberType<T>::value;
-
-/**
- * Value is true for types that are considered weak references, and false
- * otherwise.
- */
-template <typename T>
-constexpr bool IsWeakV = internal::IsWeak<T>::value;
-
-/**
- * Value is true for types that are complete, and false otherwise.
- */
-template <typename T>
-constexpr bool IsCompleteV = internal::IsComplete<T>::value;
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_TYPE_TRAITS_H_