[][src]Trait gc::Finalize

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

The Finalize trait. Can be specialized for a specific type to define finalization logic for that type.

Provided methods

fn finalize(&self)

Loading content...

Implementations on Foreign Types

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

impl Finalize for ()[src]

impl Finalize for bool[src]

impl Finalize for isize[src]

impl Finalize for usize[src]

impl Finalize for i8[src]

impl Finalize for u8[src]

impl Finalize for i16[src]

impl Finalize for u16[src]

impl Finalize for i32[src]

impl Finalize for u32[src]

impl Finalize for i64[src]

impl Finalize for u64[src]

impl Finalize for i128[src]

impl Finalize for u128[src]

impl Finalize for f32[src]

impl Finalize for f64[src]

impl Finalize for char[src]

impl Finalize for String[src]

impl Finalize for Box<str>[src]

impl Finalize for Path[src]

impl Finalize for PathBuf[src]

impl Finalize for NonZeroIsize[src]

impl Finalize for NonZeroUsize[src]

impl Finalize for NonZeroI8[src]

impl Finalize for NonZeroU8[src]

impl Finalize for NonZeroI16[src]

impl Finalize for NonZeroU16[src]

impl Finalize for NonZeroI32[src]

impl Finalize for NonZeroU32[src]

impl Finalize for NonZeroI64[src]

impl Finalize for NonZeroU64[src]

impl Finalize for NonZeroI128[src]

impl Finalize for NonZeroU128[src]

impl Finalize for AtomicBool[src]

impl Finalize for AtomicIsize[src]

impl Finalize for AtomicUsize[src]

impl Finalize for AtomicI8[src]

impl Finalize for AtomicU8[src]

impl Finalize for AtomicI16[src]

impl Finalize for AtomicU16[src]

impl Finalize for AtomicI32[src]

impl Finalize for AtomicU32[src]

impl Finalize for AtomicI64[src]

impl Finalize for AtomicU64[src]

impl<T: Trace> Finalize for [T; 0][src]

impl<T: Trace> Finalize for [T; 1][src]

impl<T: Trace> Finalize for [T; 2][src]

impl<T: Trace> Finalize for [T; 3][src]

impl<T: Trace> Finalize for [T; 4][src]

impl<T: Trace> Finalize for [T; 5][src]

impl<T: Trace> Finalize for [T; 6][src]

impl<T: Trace> Finalize for [T; 7][src]

impl<T: Trace> Finalize for [T; 8][src]

impl<T: Trace> Finalize for [T; 9][src]

impl<T: Trace> Finalize for [T; 10][src]

impl<T: Trace> Finalize for [T; 11][src]

impl<T: Trace> Finalize for [T; 12][src]

impl<T: Trace> Finalize for [T; 13][src]

impl<T: Trace> Finalize for [T; 14][src]

impl<T: Trace> Finalize for [T; 15][src]

impl<T: Trace> Finalize for [T; 16][src]

impl<T: Trace> Finalize for [T; 17][src]

impl<T: Trace> Finalize for [T; 18][src]

impl<T: Trace> Finalize for [T; 19][src]

impl<T: Trace> Finalize for [T; 20][src]

impl<T: Trace> Finalize for [T; 21][src]

impl<T: Trace> Finalize for [T; 22][src]

impl<T: Trace> Finalize for [T; 23][src]

impl<T: Trace> Finalize for [T; 24][src]

impl<T: Trace> Finalize for [T; 25][src]

impl<T: Trace> Finalize for [T; 26][src]

impl<T: Trace> Finalize for [T; 27][src]

impl<T: Trace> Finalize for [T; 28][src]

impl<T: Trace> Finalize for [T; 29][src]

impl<T: Trace> Finalize for [T; 30][src]

impl<T: Trace> Finalize for [T; 31][src]

impl<Ret> Finalize for fn() -> Ret[src]

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

impl<Ret> Finalize for unsafe fn() -> Ret[src]

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

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

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

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

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

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

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

impl<A> Finalize for (A,)[src]

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

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

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

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

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

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

impl<A, B> Finalize for (A, B)[src]

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

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

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

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

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

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

impl<A, B, C> Finalize for (A, B, C)[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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[src]

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[src]

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

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

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[src]

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[src]

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[src]

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[src]

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[src]

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

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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)[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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)[src]

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

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

impl<T: Trace> Finalize for Vec<T>[src]

impl<T: Trace> Finalize for Option<T>[src]

impl<T: Trace, E: Trace> Finalize for Result<T, E>[src]

impl<T: Ord + Trace> Finalize for BinaryHeap<T>[src]

impl<K: Trace, V: Trace> Finalize for BTreeMap<K, V>[src]

impl<T: Trace> Finalize for BTreeSet<T>[src]

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

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

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

impl<T: Trace> Finalize for VecDeque<T>[src]

Loading content...

Implementors

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

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

Loading content...