Struct drop_guard::DropGuard

pub struct DropGuard<T, F: FnMut(T)> { /* fields omitted */ }

The DropGuard will remain to Send and Sync from T.

Examples

The LinkedList<T> is Send. So the DropGuard will be too, but it will not be Sync:

use drop_guard::guard;
use std::collections::LinkedList;
use std::thread;

let list: LinkedList<u32> = LinkedList::new();

let a_list = guard(list, |_| {});

// Send the guarded list to another thread
thread::spawn(move || {
    assert_eq!(0, a_list.len());
}).join();

Implementations

impl<T: Sized, F: FnMut(T)> DropGuard<T, F>

pub fn new(data: T, func: F) -> DropGuard<T, F>

👎 Deprecated:

use drop_guard::guard that is shorter

Creates a new guard taking in your data and a function.

use drop_guard::guard;

let s = String::from("a commonString");
let mut s = guard(s, |final_string| println!("s became {} at last", final_string));

// much code and time passes by ...
*s = "a rainbow".to_string();

// by the end of this function the String will have become a rainbow

Trait Implementations

impl<T, F: FnMut(T)> Deref for DropGuard<T, F>

Use the captured value.

use drop_guard::guard;

let val = guard(42usize, |_| {});
assert_eq!(42, *val);

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, F: FnMut(T)> DerefMut for DropGuard<T, F>

Modify the captured value.

use drop_guard::guard;

let mut val = guard(vec![2, 3, 4], |_| {});
assert_eq!(3, val.len());

val.push(5);
assert_eq!(4, val.len());

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T, F: FnMut(T)> Drop for DropGuard<T, F>

React to dropping the value. In this example we measure the time the value is alive.

use drop_guard::guard;
use std::time::Instant;

let start_time = Instant::now();
let val = guard(42usize, |_| {
    let time_alive = start_time.elapsed();
    println!("value lived for {}ns", time_alive.subsec_nanos())
});
assert_eq!(42, *val);

fn drop(&mut self)

Executes the destructor for this type.