Trait boa_engine::Finalize

pub trait Finalize {
    // Provided method
    fn finalize(&self) { ... }
}

Substitute for the Drop trait for garbage collected types.

Provided Methods

fn finalize(&self)

Cleanup logic for a type.

Implementations on Foreign Types

impl Finalize for bool

impl Finalize for char

impl Finalize for f32

impl Finalize for f64

impl Finalize for i8

impl Finalize for i16

impl Finalize for i32

impl Finalize for i64

impl Finalize for i128

impl Finalize for isize

impl Finalize for u8

impl Finalize for u16

impl Finalize for u32

impl Finalize for u64

impl Finalize for u128

impl Finalize for ()

impl Finalize for usize

impl Finalize for Box<str>

impl Finalize for Rc<str>

impl Finalize for String

impl Finalize for TypeId

impl Finalize for NonZero<i8>

impl Finalize for NonZero<i16>

impl Finalize for NonZero<i32>

impl Finalize for NonZero<i64>

impl Finalize for NonZero<i128>

impl Finalize for NonZero<isize>

impl Finalize for NonZero<u8>

impl Finalize for NonZero<u16>

impl Finalize for NonZero<u32>

impl Finalize for NonZero<u64>

impl Finalize for NonZero<u128>

impl Finalize for NonZero<usize>

impl Finalize for AtomicBool

impl Finalize for AtomicI8

impl Finalize for AtomicI16

impl Finalize for AtomicI32

impl Finalize for AtomicI64

impl Finalize for AtomicIsize

impl Finalize for AtomicU8

impl Finalize for AtomicU16

impl Finalize for AtomicU32

impl Finalize for AtomicU64

impl Finalize for AtomicUsize

impl Finalize for Path

impl Finalize for PathBuf

impl Finalize for Sym

impl<A> Finalize for (A,)

impl<A, B> Finalize for (A, B)

impl<A, B, C> Finalize for (A, B, C)

impl<A, B, C, D> Finalize for (A, B, C, D)

impl<A, B, C, D, E> Finalize for (A, B, C, D, E)

impl<A, B, C, D, E, F> Finalize for (A, B, C, D, E, F)

impl<A, B, C, D, E, F, G> Finalize for (A, B, C, D, E, F, G)

impl<A, B, C, D, E, F, G, H> Finalize for (A, B, C, D, E, F, G, H)

impl<A, B, C, D, E, F, G, H, I> Finalize for (A, B, C, D, E, F, G, H, I)

impl<A, B, C, D, E, F, G, H, I, J> Finalize for (A, B, C, D, E, F, G, H, I, J)

impl<A, B, C, D, E, F, G, H, I, J, K> Finalize for (A, B, C, D, E, F, G, H, I, J, K)

impl<A, B, C, D, E, F, G, H, I, J, K, L> Finalize for (A, B, C, D, E, F, G, H, I, J, K, L)

impl<K, V> Finalize for BTreeMap<K, V>

where K: Trace, V: Trace,

impl<K, V, S> Finalize for HashMap<K, V, S>

where K: Eq + Hash + Trace, V: Trace, S: BuildHasher,

impl<K, V, S> Finalize for HashMap<K, V, S>

where K: Eq + Hash + Trace, V: Trace, S: BuildHasher,

impl<Ret> Finalize for fn() -> Ret

impl<Ret> Finalize for extern "C" fn() -> Ret

impl<Ret> Finalize for unsafe fn() -> Ret

impl<Ret> Finalize for unsafe extern "C" fn() -> Ret

impl<Ret, A> Finalize for fn(_: A) -> Ret

impl<Ret, A> Finalize for extern "C" fn(_: A) -> Ret

impl<Ret, A> Finalize for extern "C" fn(_: A, ...) -> Ret

impl<Ret, A> Finalize for unsafe fn(_: A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(_: A) -> Ret

impl<Ret, A> Finalize for unsafe extern "C" fn(_: A, ...) -> Ret

impl<Ret, A, B> Finalize for fn(_: A, _: B) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(_: A, _: B) -> Ret

impl<Ret, A, B> Finalize for extern "C" fn(_: A, _: B, ...) -> Ret

impl<Ret, A, B> Finalize for unsafe fn(_: A, _: B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(_: A, _: B) -> Ret

impl<Ret, A, B> Finalize for unsafe extern "C" fn(_: A, _: B, ...) -> Ret

impl<Ret, A, B, C> Finalize for fn(_: A, _: B, _: C) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(_: A, _: B, _: C) -> Ret

impl<Ret, A, B, C> Finalize for extern "C" fn(_: A, _: B, _: C, ...) -> Ret

impl<Ret, A, B, C> Finalize for unsafe fn(_: A, _: B, _: C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(_: A, _: B, _: C) -> Ret

impl<Ret, A, B, C> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for fn(_: A, _: B, _: C, _: D) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(_: A, _: B, _: C, _: D) -> Ret

impl<Ret, A, B, C, D> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe fn(_: A, _: B, _: C, _: D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D) -> Ret

impl<Ret, A, B, C, D> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for fn(_: A, _: B, _: C, _: D, _: E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret

impl<Ret, A, B, C, D, E> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F) -> Ret

impl<Ret, A, B, C, D, E, F> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> Ret

impl<Ret, A, B, C, D, E, F, G> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

impl<Ret, A, B, C, D, E, F, G, H> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L) -> Ret

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H, _: I, _: J, _: K, _: L, ...) -> Ret

impl<T> Finalize for Cow<'static, T>

where T: ToOwned + Trace + ?Sized,

impl<T> Finalize for Option<T>

where T: Trace,

impl<T> Finalize for &'static T

where T: ?Sized,

impl<T> Finalize for Box<[T]>

where T: Trace,

impl<T> Finalize for Box<T>

where T: Trace + ?Sized,

impl<T> Finalize for BinaryHeap<T>

where T: Ord + Trace,

impl<T> Finalize for BTreeSet<T>

where T: Trace,

impl<T> Finalize for LinkedList<T>

where T: Eq + Hash + Trace,

impl<T> Finalize for VecDeque<T>

where T: Trace,

impl<T> Finalize for Vec<T>

where T: Trace,

impl<T> Finalize for OnceCell<T>

where T: Trace,

impl<T> Finalize for Cell<Option<T>>

where T: Trace,

impl<T> Finalize for PhantomData<T>

impl<T> Finalize for ThinVec<T>

where T: Trace,

impl<T, E> Finalize for Result<T, E>

where T: Trace, E: Trace,

impl<T, S> Finalize for HashSet<T, S>

where T: Eq + Hash + Trace, S: BuildHasher,

impl<T, const N: usize> Finalize for [T; N]

where T: Trace,

Implementors

impl Finalize for ErrorObject

impl Finalize for ClassFieldDefinition

impl Finalize for ThisMode

impl Finalize for PromiseState

impl Finalize for JsErasedNativeErrorKind

impl Finalize for JsNativeErrorKind

impl Finalize for PrivateElement

impl Finalize for DescriptorKind

impl Finalize for PropertyKey

impl Finalize for JsValue

impl Finalize for JsBigInt

impl Finalize for ArrayBuffer

impl Finalize for SharedArrayBuffer

impl Finalize for AsyncGenerator

impl Finalize for DataView

impl Finalize for Date

impl Finalize for BoundFunction

impl Finalize for OrdinaryFunction

impl Finalize for Generator

impl Finalize for IteratorPrototypes

impl Finalize for IteratorRecord

impl Finalize for IteratorResult

impl Finalize for OrdinaryObject

impl Finalize for Promise

impl Finalize for ResolvingFunctions

impl Finalize for Proxy

impl Finalize for RegExp

impl Finalize for OrderedSet

impl Finalize for TypedArray

impl Finalize for UriFunctions

impl Finalize for IntrinsicObjects

impl Finalize for Intrinsics

impl Finalize for StandardConstructor

impl Finalize for StandardConstructors

impl Finalize for JsErasedError

impl Finalize for JsErasedNativeError

impl Finalize for JsError

impl Finalize for JsNativeError

impl Finalize for JobCallback

impl Finalize for Module

impl Finalize for ModuleNamespace

impl Finalize for SyntheticModule

impl Finalize for SyntheticModuleInitializer

impl Finalize for NativeFunction

impl Finalize for NativeFunctionObject

impl Finalize for JsArray

impl Finalize for JsArrayBuffer

impl Finalize for JsDataView

impl Finalize for JsDate

impl Finalize for JsFloat32Array

impl Finalize for JsFloat64Array

impl Finalize for JsFunction

impl Finalize for JsGenerator

impl Finalize for JsInt8Array

impl Finalize for JsInt16Array

impl Finalize for JsInt32Array

impl Finalize for JsMap

impl Finalize for JsMapIterator

impl Finalize for JsPromise

impl Finalize for JsProxy

impl Finalize for JsRegExp

impl Finalize for JsRevocableProxy

impl Finalize for JsSet

impl Finalize for JsSetIterator

impl Finalize for JsSharedArrayBuffer

impl Finalize for JsTypedArray

impl Finalize for JsUint8Array

impl Finalize for JsUint16Array

impl Finalize for JsUint32Array

impl Finalize for RootShape

impl Finalize for Shape

impl Finalize for SharedShape

impl Finalize for PrivateName

impl Finalize for PropertyMap

impl Finalize for HostDefined

impl Finalize for PropertyDescriptor

impl Finalize for Realm

impl Finalize for Script

impl Finalize for JsString

impl Finalize for JsSymbol

impl Finalize for CallFrame

impl Finalize for CodeBlock

impl<K, V> Finalize for Ephemeron<K, V>

where K: Trace + ?Sized, V: Trace,

impl<K, V> Finalize for WeakMap<K, V>

where K: Trace + 'static + ?Sized, V: Trace + 'static,

impl<T> Finalize for GcRefCell<T>

where T: Trace + ?Sized,

impl<T> Finalize for Gc<T>

where T: Trace + ?Sized,

impl<T> Finalize for WeakGc<T>

where T: Trace + 'static + ?Sized,

impl<T: NativeObject + ?Sized> Finalize for JsObject<T>

impl<T: ?Sized> Finalize for Object<T>

impl<V> Finalize for OrderedMap<V>