Trait gc::Finalize

pub trait Finalize {
    // Provided method
    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: Finalize> Finalize for BinaryHeap<T>

fn finalize(&self)

impl Finalize for f64

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> Finalize for unsafe extern "C" fn(_: A) -> Ret

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

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

impl Finalize for u8

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 fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, _: H) -> Ret

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

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

impl Finalize for Rc<str>

impl Finalize for u16

impl Finalize for i128

impl Finalize for usize

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 extern "C" fn(_: A, _: B, _: C, _: D, _: E) -> Ret

impl Finalize for f32

impl Finalize for String

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

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

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

fn finalize(&self)

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

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

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

fn finalize(&self)

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

fn finalize(&self)

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

fn finalize(&self)

impl Finalize for NonZeroI128

impl Finalize for AtomicIsize

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

impl Finalize for u32

impl Finalize for NonZeroU8

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

fn finalize(&self)

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

fn finalize(&self)

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 Finalize for NonZeroU64

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

fn finalize(&self)

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 Finalize for i32

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

fn finalize(&self)

impl Finalize for ()

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

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

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

impl Finalize for str

impl Finalize for char

impl Finalize for NonZeroI64

impl Finalize for SipHasher

impl Finalize for u64

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

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

impl Finalize for AtomicUsize

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

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

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 Finalize for AtomicI16

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 Finalize for DefaultHasher

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

fn finalize(&self)

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

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

impl<T: Finalize> Finalize for [T]

fn finalize(&self)

impl Finalize for AtomicU64

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

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

impl Finalize for AtomicU16

impl Finalize for NonZeroU32

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 Finalize for AtomicI32

impl<T> Finalize for BuildHasherDefault<T>

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

fn finalize(&self)

impl<T: Finalize> Finalize for LinkedList<T>

fn finalize(&self)

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

impl Finalize for NonZeroI32

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

impl Finalize for bool

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

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

fn finalize(&self)

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

fn finalize(&self)

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

fn finalize(&self)

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 Finalize for i16

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, 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> Finalize for extern "C" fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G, ...) -> Ret

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

fn finalize(&self)

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> Finalize for unsafe fn(_: A, _: B, _: C, _: D, _: E) -> Ret

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

impl Finalize for isize

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

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

fn finalize(&self)

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

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

fn finalize(&self)

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> Finalize for unsafe fn(_: A) -> Ret

impl Finalize for AtomicI64

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

impl Finalize for NonZeroI16

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<K: Finalize, V: Finalize> Finalize for BTreeMap<K, V>

fn finalize(&self)

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

impl Finalize for i64

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

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

fn finalize(&self)

impl Finalize for Path

impl Finalize for NonZeroU16

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> Finalize for extern "C" fn(_: A, _: B, ...) -> Ret

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

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

fn finalize(&self)

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

fn finalize(&self)

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

impl Finalize for AtomicU32

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

impl Finalize for NonZeroUsize

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

impl Finalize for u128

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

fn finalize(&self)

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 Finalize for AtomicI8

impl Finalize for NonZeroIsize

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

impl Finalize for AtomicBool

impl Finalize for RandomState

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

impl Finalize for AtomicU8

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

fn finalize(&self)

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

impl Finalize for NonZeroU128

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 Finalize for PathBuf

impl Finalize for NonZeroI8

impl<Ret, A, B, C> Finalize for fn(_: A, _: B, _: C) -> 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, T: ToOwned + ?Sized> Finalize for Cow<'a, T>where T::Owned: Finalize,

fn finalize(&self)

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, 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> Finalize for unsafe extern "C" fn(_: A, _: B, _: C, ...) -> Ret

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

impl Finalize for i8

Implementors

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

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