[−][src]Trait boa::gc::Finalize

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

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

Provided methods

pub fn finalize(&self)[src]

Loading content...

Implementations on Foreign Types

impl Finalize for u32[src]

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

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

impl Finalize for AtomicI64[src]

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

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

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

impl Finalize for AtomicU32[src]

impl Finalize for i32[src]

impl<T> Finalize for Vec<T, Global> where
    T: Trace, [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 Finalize for u8[src]

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

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

impl Finalize for NonZeroIsize[src]

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

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

impl<Ret, A, B, C> Finalize for fn(A, B, C) -> 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<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> Finalize for [T; 24] where
    T: Trace, [src]

impl Finalize for Path[src]

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

impl Finalize for NonZeroU8[src]

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

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

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

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

impl<Ret> Finalize for unsafe fn() -> 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 Finalize for NonZeroI128[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, F, G> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret[src]

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

impl Finalize for NonZeroI64[src]

impl Finalize for AtomicU64[src]

impl Finalize for isize[src]

impl<T> Finalize for Gc<T> where
    T: Trace + ?Sized, [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, 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> Finalize for (A, B, C, D, E)[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, 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, 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> Finalize for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src]

impl Finalize for AtomicI8[src]

impl Finalize for NonZeroI8[src]

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

impl Finalize for AtomicIsize[src]

impl Finalize for i16[src]

impl<Ret> Finalize for fn() -> Ret[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> Finalize for unsafe fn(A, B, C, D, E, F, G, H) -> Ret[src]

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

impl Finalize for NonZeroI16[src]

impl<T> Finalize for [T; 26] where
    T: Trace, [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<T> Finalize for LinkedList<T> where
    T: Trace + Eq + Hash, [src]

impl Finalize for u64[src]

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

impl<Ret, A, B, C> Finalize for extern "C" fn(A, B, C, ...) -> 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> Finalize for extern "C" fn(A, B, C, D, E, ...) -> Ret[src]

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

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

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

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

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

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

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

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

impl Finalize for NonZeroU64[src]

impl Finalize for AtomicBool[src]

impl<T> Finalize for [T; 1] where
    T: Trace, [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 Finalize for AtomicU16[src]

impl Finalize for char[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, F, G> Finalize for extern "C" fn(A, B, C, D, E, F, G) -> 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 Finalize for u128[src]

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

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

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

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

impl Finalize for NonZeroI32[src]

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

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

impl Finalize for AtomicI16[src]

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

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

impl<T> Finalize for [T; 8] where
    T: Trace, [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, F> Finalize for extern "C" fn(A, B, C, D, E, F) -> 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<A, B, C, D, E, F> Finalize for (A, B, C, D, E, F)[src]

impl<T> Finalize for [T; 30] where
    T: Trace, [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> Finalize for extern "C" fn(A, B, C, D, E, F, ...) -> 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, F, G, H, I> Finalize for fn(A, B, C, D, E, F, G, H, I) -> Ret[src]

impl Finalize for f64[src]

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

impl<Ret> Finalize for extern "C" fn() -> 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<T> Finalize for [T; 27] where
    T: Trace, [src]

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

impl<Ret, A, B> Finalize for fn(A, B) -> 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 Finalize for NonZeroU128[src]

impl Finalize for f32[src]

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

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

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

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

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

impl Finalize for AtomicUsize[src]

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

impl Finalize for usize[src]

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

impl Finalize for NonZeroUsize[src]

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

impl Finalize for i128[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> 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 unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[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 Finalize for i64[src]

impl<T> Finalize for [T; 20] where
    T: Trace, [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> Finalize for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> 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> Finalize for (A, B, C, D, E, F, G, H)[src]

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

impl<T> Finalize for Box<T, Global> where
    T: Trace + ?Sized, [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 fn(A, B, C, D, E, F, G, H, I, J, K) -> 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<T> Finalize for [T; 22] where
    T: Trace, [src]

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

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

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

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

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

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

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

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

impl<T> Finalize for [T; 13] where
    T: Trace, [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 Finalize for NonZeroU32[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> Finalize for unsafe fn(A, B, C, D, E, F) -> Ret[src]

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

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

impl Finalize for PathBuf[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 Finalize for Box<str, Global>[src]

impl Finalize for String[src]

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

impl Finalize for ()[src]

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

impl Finalize for i8[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<T> Finalize for [T; 4] where
    T: Trace, [src]

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

impl Finalize for u16[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<T> Finalize for VecDeque<T> where
    T: Trace, [src]

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

impl Finalize for bool[src]

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

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

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

impl Finalize for NonZeroU16[src]

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

impl Finalize for AtomicU8[src]

Loading content...

Implementors

impl Finalize for ArrayIterationKind[src]

impl Finalize for Function[src]

impl Finalize for MapIterationKind[src]

impl Finalize for Value[src]

impl Finalize for BindingStatus[src]

impl Finalize for ObjectData[src]

impl Finalize for PropertyDescriptor[src]

impl Finalize for PropertyKey[src]

impl Finalize for Const[src]

impl Finalize for MethodDefinitionKind[src]

impl Finalize for Node[src]

impl Finalize for PropertyDefinition[src]

impl Finalize for TemplateElement[src]

impl Finalize for AssignOp[src]

impl Finalize for boa::syntax::ast::op::BinOp[src]

impl Finalize for BitOp[src]

impl Finalize for CompOp[src]

impl Finalize for LogOp[src]

impl Finalize for NumOp[src]

impl Finalize for boa::syntax::ast::op::UnaryOp[src]

impl Finalize for ArrayIterator[src]

impl Finalize for BigInt[src]

impl Finalize for Date[src]

impl Finalize for BuiltInFunction[src]

impl Finalize for FunctionFlags[src]

impl Finalize for MapIterator[src]

impl Finalize for ForInIterator[src]

impl Finalize for RegExp[src]

impl Finalize for StringIterator[src]

impl Finalize for Symbol[src]

impl Finalize for DeclarativeEnvironmentRecord[src]

impl Finalize for DeclarativeEnvironmentRecordBinding[src]

impl Finalize for FunctionEnvironmentRecord[src]

impl Finalize for GlobalEnvironmentRecord[src]

impl Finalize for ObjectEnvironmentRecord[src]

impl Finalize for GcObject[src]

impl Finalize for boa::object::Object[src]

impl Finalize for AccessorDescriptor[src]

impl Finalize for Attribute[src]

impl Finalize for DataDescriptor[src]

impl Finalize for ArrayDecl[src]

impl Finalize for AwaitExpr[src]

impl Finalize for Block[src]

impl Finalize for Break[src]

impl Finalize for Call[src]

impl Finalize for ConditionalOp[src]

impl Finalize for If[src]

impl Finalize for ArrowFunctionDecl[src]

impl Finalize for AsyncFunctionDecl[src]

impl Finalize for AsyncFunctionExpr[src]

impl Finalize for ConstDecl[src]

impl Finalize for ConstDeclList[src]

impl Finalize for FunctionDecl[src]

impl Finalize for FunctionExpr[src]

impl Finalize for LetDecl[src]

impl Finalize for LetDeclList[src]

impl Finalize for VarDecl[src]

impl Finalize for VarDeclList[src]

impl Finalize for GetConstField[src]

impl Finalize for GetField[src]

impl Finalize for Identifier[src]

impl Finalize for Continue[src]

impl Finalize for DoWhileLoop[src]

impl Finalize for ForInLoop[src]

impl Finalize for ForLoop[src]

impl Finalize for ForOfLoop[src]

impl Finalize for WhileLoop[src]

impl Finalize for New[src]

impl Finalize for boa::syntax::ast::node::object::Object[src]

impl Finalize for Assign[src]

impl Finalize for boa::syntax::ast::node::operator::bin_op::BinOp[src]

impl Finalize for boa::syntax::ast::node::operator::unary_op::UnaryOp[src]

impl Finalize for Return[src]

impl Finalize for Spread[src]

impl Finalize for RcStatementList[src]

impl Finalize for StatementList[src]

impl Finalize for FormalParameter[src]

impl Finalize for Case[src]

impl Finalize for Switch[src]

impl Finalize for TaggedTemplate[src]

impl Finalize for TemplateLit[src]

impl Finalize for Throw[src]

impl Finalize for Catch[src]

impl Finalize for Finally[src]

impl Finalize for Try[src]

impl Finalize for RcBigInt[src]

impl Finalize for RcString[src]

impl Finalize for RcSymbol[src]

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

Loading content...