1.0.0[][src]Trait sgx_tstd::ops::Drop

#[lang = "drop"]pub trait Drop {
    fn drop(&mut self);
}

Used to run some code when a value goes out of scope. This is sometimes called a 'destructor'.

When a value goes out of scope, it will have its drop method called if its type implements Drop. Then, any fields the value contains will also be dropped recursively.

Because of this recursive dropping, you do not need to implement this trait unless your type needs its own destructor logic.

Refer to the chapter on Drop in The Rust Programming Language for some more elaboration.

Examples

Implementing Drop

The drop method is called when _x goes out of scope, and therefore main prints Dropping!.

struct HasDrop;

impl Drop for HasDrop {
    fn drop(&mut self) {
        println!("Dropping!");
    }
}

fn main() {
    let _x = HasDrop;
}

Dropping is done recursively

When outer goes out of scope, the drop method will be called first for Outer, then for Inner. Therefore, main prints Dropping Outer! and then Dropping Inner!.

struct Inner;
struct Outer(Inner);

impl Drop for Inner {
    fn drop(&mut self) {
        println!("Dropping Inner!");
    }
}

impl Drop for Outer {
    fn drop(&mut self) {
        println!("Dropping Outer!");
    }
}

fn main() {
    let _x = Outer(Inner);
}

Variables are dropped in reverse order of declaration

_first is declared first and _second is declared second, so main will print Declared second! and then Declared first!.

struct PrintOnDrop(&'static str);

impl Drop for PrintOnDrop {
    fn drop(&mut self) {
        println!("{}", self.0);
    }
}

fn main() {
    let _first = PrintOnDrop("Declared first!");
    let _second = PrintOnDrop("Declared second!");
}

Required methods

fn drop(&mut self)

Executes the destructor for this type.

This method is called implicitly when the value goes out of scope, and cannot be called explicitly (this is compiler error E0040). However, the std::mem::drop function in the prelude can be used to call the argument's Drop implementation.

When this method has been called, self has not yet been deallocated. That only happens after the method is over. If this wasn't the case, self would be a dangling reference.

Panics

Given that a panic! will call drop as it unwinds, any panic! in a drop implementation will likely abort.

Note that even if this panics, the value is considered to be dropped; you must not cause drop to be called again. This is normally automatically handled by the compiler, but when using unsafe code, can sometimes occur unintentionally, particularly when using std::ptr::drop_in_place.

Loading content...

Implementations on Foreign Types

impl<'a, K, V, F> Drop for DrainFilter<'a, K, V, F> where
    F: FnMut(&K, &mut V) -> bool, 
[src]

impl<T> Drop for AlignBox<T>[src]

impl Drop for SgxFileStream[src]

Loading content...

Implementors

impl Drop for CString[src]

impl Drop for SgxCondvar[src]

impl Drop for Waker[src]

impl<'_> Drop for sgx_tstd::string::Drain<'_>[src]

impl<'_, I> Drop for Splice<'_, I> where
    I: Iterator
[src]

impl<'_, T> Drop for PeekMut<'_, T> where
    T: Ord
[src]

impl<'_, T> Drop for sgx_tstd::collections::vec_deque::Drain<'_, T>[src]

impl<'_, T> Drop for SgxReentrantMutexGuard<'_, T>[src]

impl<'_, T> Drop for sgx_tstd::vec::Drain<'_, T>[src]

impl<'_, T, F> Drop for sgx_tstd::collections::linked_list::DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool, 
[src]

impl<'_, T, F> Drop for sgx_tstd::vec::DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool, 
[src]

impl<'_, T: ?Sized> Drop for SgxMutexGuard<'_, T>[src]

impl<'_, T: ?Sized> Drop for SgxRwLockReadGuard<'_, T>[src]

impl<'_, T: ?Sized> Drop for SgxRwLockWriteGuard<'_, T>[src]

impl<'a> Drop for SgxSpinlockGuard<'a>[src]

impl<'a, K, V, F> Drop for sgx_tstd::collections::btree_map::DrainFilter<'a, K, V, F> where
    F: 'a + FnMut(&K, &mut V) -> bool,
    K: 'a + Ord,
    V: 'a, 
[src]

impl<'a, T> Drop for DrainSorted<'a, T> where
    T: Ord
[src]

fn drop(&mut self)[src]

Removes heap elements in heap order.

impl<'a, T, F> Drop for sgx_tstd::collections::btree_set::DrainFilter<'a, T, F> where
    F: 'a + FnMut(&T) -> bool,
    T: 'a + Ord
[src]

impl<'f> Drop for VaListImpl<'f>[src]

impl<K, V> Drop for sgx_tstd::collections::btree_map::IntoIter<K, V>[src]

impl<K, V> Drop for BTreeMap<K, V>[src]

impl<T> Drop for Box<T> where
    T: ?Sized
[src]

impl<T> Drop for LinkedList<T>[src]

impl<T> Drop for VecDeque<T>[src]

impl<T> Drop for Rc<T> where
    T: ?Sized
[src]

fn drop(&mut self)[src]

Drops the Rc.

This will decrement the strong reference count. If the strong reference count reaches zero then the only other references (if any) are Weak, so we drop the inner value.

Examples

use std::rc::Rc;

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo  = Rc::new(Foo);
let foo2 = Rc::clone(&foo);

drop(foo);    // Doesn't print anything
drop(foo2);   // Prints "dropped!"

impl<T> Drop for sgx_tstd::rc::Weak<T> where
    T: ?Sized
[src]

fn drop(&mut self)[src]

Drops the Weak pointer.

Examples

use std::rc::{Rc, Weak};

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo = Rc::new(Foo);
let weak_foo = Rc::downgrade(&foo);
let other_weak_foo = Weak::clone(&weak_foo);

drop(weak_foo);   // Doesn't print anything
drop(foo);        // Prints "dropped!"

assert!(other_weak_foo.upgrade().is_none());

impl<T> Drop for Arc<T> where
    T: ?Sized
[src]

fn drop(&mut self)[src]

Drops the Arc.

This will decrement the strong reference count. If the strong reference count reaches zero then the only other references (if any) are Weak, so we drop the inner value.

Examples

use std::sync::Arc;

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo  = Arc::new(Foo);
let foo2 = Arc::clone(&foo);

drop(foo);    // Doesn't print anything
drop(foo2);   // Prints "dropped!"

impl<T> Drop for SgxReentrantMutex<T>[src]

impl<T> Drop for sgx_tstd::sync::Weak<T> where
    T: ?Sized
[src]

fn drop(&mut self)[src]

Drops the Weak pointer.

Examples

use std::sync::{Arc, Weak};

struct Foo;

impl Drop for Foo {
    fn drop(&mut self) {
        println!("dropped!");
    }
}

let foo = Arc::new(Foo);
let weak_foo = Arc::downgrade(&foo);
let other_weak_foo = Weak::clone(&weak_foo);

drop(weak_foo);   // Doesn't print anything
drop(foo);        // Prints "dropped!"

assert!(other_weak_foo.upgrade().is_none());

impl<T> Drop for sgx_tstd::vec::IntoIter<T>[src]

impl<T> Drop for Vec<T>[src]

impl<T: ?Sized> Drop for SgxMutex<T>[src]

impl<T: ?Sized> Drop for SgxRwLock<T>[src]

impl<W: Write> Drop for BufWriter<W>[src]

impl<const N: usize, T> Drop for sgx_tstd::array::IntoIter<T, N> where
    [T; N]: LengthAtMost32
[src]

Loading content...