Trait jrsonnet_gc::Finalize

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

The Finalize trait, which needs to be implemented on garbage-collected objects to define finalization logic.

Provided methods

fn finalize(&self)

Implementations on Foreign Types

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

impl Finalize for ()

impl Finalize for bool

impl Finalize for isize

impl Finalize for usize

impl Finalize for i8

impl Finalize for u8

impl Finalize for i16

impl Finalize for u16

impl Finalize for i32

impl Finalize for u32

impl Finalize for i64

impl Finalize for u64

impl Finalize for i128

impl Finalize for u128

impl Finalize for f32

impl Finalize for f64

impl Finalize for char

impl Finalize for String

impl Finalize for Box<str>

impl Finalize for Rc<str>

impl Finalize for Rc<Path>

impl Finalize for Path

impl Finalize for PathBuf

impl Finalize for NonZeroIsize

impl Finalize for NonZeroUsize

impl Finalize for NonZeroI8

impl Finalize for NonZeroU8

impl Finalize for NonZeroI16

impl Finalize for NonZeroU16

impl Finalize for NonZeroI32

impl Finalize for NonZeroU32

impl Finalize for NonZeroI64

impl Finalize for NonZeroU64

impl Finalize for NonZeroI128

impl Finalize for NonZeroU128

impl Finalize for AtomicBool

impl Finalize for AtomicIsize

impl Finalize for AtomicUsize

impl Finalize for AtomicI8

impl Finalize for AtomicU8

impl Finalize for AtomicI16

impl Finalize for AtomicU16

impl Finalize for AtomicI32

impl Finalize for AtomicU32

impl Finalize for AtomicI64

impl Finalize for AtomicU64

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

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<A> Finalize for (A,)

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<A, B> Finalize for (A, B)

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<A, B, C> Finalize for (A, B, C)

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<A, B, C, D> Finalize for (A, B, C, D)

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<A, B, C, D, E> Finalize for (A, B, C, D, E)

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<A, B, C, D, E, F> Finalize for (A, B, C, D, E, F)

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<A, B, C, D, E, F, G> Finalize for (A, B, C, D, E, F, G)

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<A, B, C, D, E, F, G, H> Finalize for (A, B, C, D, E, F, G, H)

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<A, B, C, D, E, F, G, H, I> Finalize for (A, B, C, D, E, F, G, H, I)

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<A, B, C, D, E, F, G, H, I, J> Finalize for (A, B, C, D, E, F, G, H, I, J)

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<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<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<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<T: Trace + ?Sized> Finalize for Box<T>

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

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

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

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

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

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

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

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

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

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

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

Implementors

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

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