Trait boa_gc::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 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 NonZeroI8

impl Finalize for NonZeroI16

impl Finalize for NonZeroI32

impl Finalize for NonZeroI64

impl Finalize for NonZeroI128

impl Finalize for NonZeroIsize

impl Finalize for NonZeroU8

impl Finalize for NonZeroU16

impl Finalize for NonZeroU32

impl Finalize for NonZeroU64

impl Finalize for NonZeroU128

impl Finalize for NonZeroUsize

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: Eq + Hash + Trace, V: Trace, S: BuildHasher> Finalize for HashMap<K, V, S>

impl<K: Eq + Hash + Trace, V: Trace, S: BuildHasher> Finalize for HashMap<K, V, S>

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

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 PhantomData<T>

impl<T: ToOwned + Trace + ?Sized> Finalize for Cow<'static, T>

impl<T: Eq + Hash + Trace> Finalize for LinkedList<T>

impl<T: Eq + Hash + Trace, S: BuildHasher> Finalize for HashSet<T, S>

impl<T: Ord + Trace> Finalize for BinaryHeap<T>

impl<T: Trace + ?Sized> Finalize for Box<T>

impl<T: Trace> Finalize for Option<T>

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

impl<T: Trace> Finalize for BTreeSet<T>

impl<T: Trace> Finalize for VecDeque<T>

impl<T: Trace> Finalize for Vec<T>

impl<T: Trace> Finalize for OnceCell<T>

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

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

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

impl<T: ?Sized> Finalize for &'static T

Implementors

impl<K: Trace + ?Sized + 'static, V: Trace + 'static> Finalize for WeakMap<K, V>

impl<K: Trace + ?Sized, V: Trace> Finalize for Ephemeron<K, V>

impl<T: Trace + ?Sized + 'static> Finalize for WeakGc<T>

impl<T: Trace + ?Sized> Finalize for Gc<T>

impl<T: Trace + ?Sized> Finalize for GcRefCell<T>