Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/node/cppgc/trace-trait.h


$ cat -n /usr/include/node/cppgc/trace-trait.h

     1	// Copyright 2020 the V8 project authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style license that can be
     3	// found in the LICENSE file.
     4	
     5	#ifndef INCLUDE_CPPGC_TRACE_TRAIT_H_
     6	#define INCLUDE_CPPGC_TRACE_TRAIT_H_
     7	
     8	#include <type_traits>
     9	
    10	#include "cppgc/type-traits.h"
    11	#include "v8config.h"  // NOLINT(build/include_directory)
    12	
    13	namespace cppgc {
    14	
    15	class Visitor;
    16	
    17	namespace internal {
    18	
    19	class RootVisitor;
    20	
    21	using TraceRootCallback = void (*)(RootVisitor&, const void* object);
    22	
    23	// Implementation of the default TraceTrait handling GarbageCollected and
    24	// GarbageCollectedMixin.
    25	template <typename T,
    26	          bool =
    27	              IsGarbageCollectedMixinTypeV<typename std::remove_const<T>::type>>
    28	struct TraceTraitImpl;
    29	
    30	}  // namespace internal
    31	
    32	/**
    33	 * Callback for invoking tracing on a given object.
    34	 *
    35	 * \param visitor The visitor to dispatch to.
    36	 * \param object The object to invoke tracing on.
    37	 */
    38	using TraceCallback = void (*)(Visitor* visitor, const void* object);
    39	
    40	/**
    41	 * Describes how to trace an object, i.e., how to visit all Oilpan-relevant
    42	 * fields of an object.
    43	 */
    44	struct TraceDescriptor {
    45	  /**
    46	   * Adjusted base pointer, i.e., the pointer to the class inheriting directly
    47	   * from GarbageCollected, of the object that is being traced.
    48	   */
    49	  const void* base_object_payload;
    50	  /**
    51	   * Callback for tracing the object.
    52	   */
    53	  TraceCallback callback;
    54	};
    55	
    56	/**
    57	 * Callback for getting a TraceDescriptor for a given address.
    58	 *
    59	 * \param address Possibly inner address of an object.
    60	 * \returns a TraceDescriptor for the provided address.
    61	 */
    62	using TraceDescriptorCallback = TraceDescriptor (*)(const void* address);
    63	
    64	namespace internal {
    65	
    66	struct V8_EXPORT TraceTraitFromInnerAddressImpl {
    67	  static TraceDescriptor GetTraceDescriptor(const void* address);
    68	};
    69	
    70	/**
    71	 * Trait specifying how the garbage collector processes an object of type T.
    72	 *
    73	 * Advanced users may override handling by creating a specialization for their
    74	 * type.
    75	 */
    76	template <typename T>
    77	struct TraceTraitBase {
    78	  static_assert(internal::IsTraceableV<T>, "T must have a Trace() method");
    79	
    80	  /**
    81	   * Accessor for retrieving a TraceDescriptor to process an object of type T.
    82	   *
    83	   * \param self The object to be processed.
    84	   * \returns a TraceDescriptor to process the object.
    85	   */
    86	  static TraceDescriptor GetTraceDescriptor(const void* self) {
    87	    return internal::TraceTraitImpl<T>::GetTraceDescriptor(
    88	        static_cast<const T*>(self));
    89	  }
    90	
    91	  /**
    92	   * Function invoking the tracing for an object of type T.
    93	   *
    94	   * \param visitor The visitor to dispatch to.
    95	   * \param self The object to invoke tracing on.
    96	   */
    97	  static void Trace(Visitor* visitor, const void* self) {
    98	    static_cast<const T*>(self)->Trace(visitor);
    99	  }
   100	};
   101	
   102	}  // namespace internal
   103	
   104	template <typename T>
   105	struct TraceTrait : public internal::TraceTraitBase<T> {};
   106	
   107	namespace internal {
   108	
   109	template <typename T>
   110	struct TraceTraitImpl<T, false> {
   111	  static_assert(IsGarbageCollectedTypeV<T>,
   112	                "T must be of type GarbageCollected or GarbageCollectedMixin");
   113	  static TraceDescriptor GetTraceDescriptor(const void* self) {
   114	    return {self, TraceTrait<T>::Trace};
   115	  }
   116	};
   117	
   118	template <typename T>
   119	struct TraceTraitImpl<T, true> {
   120	  static TraceDescriptor GetTraceDescriptor(const void* self) {
   121	    return internal::TraceTraitFromInnerAddressImpl::GetTraceDescriptor(self);
   122	  }
   123	};
   124	
   125	}  // namespace internal
   126	}  // namespace cppgc
   127	
   128	#endif  // INCLUDE_CPPGC_TRACE_TRAIT_H_