Struct scopeguard::ScopeGuard

pub struct ScopeGuard<T, F, S = Always> where
    F: FnOnce(T),
    S: Strategy,  { /* fields omitted */ }

ScopeGuard is a scope guard that may own a protected value.

If you place a guard in a local variable, the closure can run regardless how you leave the scope — through regular return or panic (except if panic or other code aborts; so as long as destructors run). It is run only once.

The S parameter for Strategy determines if the closure actually runs.

The guard's closure will be called with the held value in the destructor.

The ScopeGuard implements Deref so that you can access the inner value.

Methods

impl<T, F, S> ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy, 

pub fn with_strategy(v: T, dropfn: F) -> ScopeGuard<T, F, S>

Create a ScopeGuard that owns v (accessible through deref) and calls dropfn when its destructor runs.

The Strategy decides whether the scope guard's closure should run.

pub fn into_inner(guard: Self) -> T

“Defuse” the guard and extract the value without calling the closure.

extern crate scopeguard;

use scopeguard::{guard, ScopeGuard};

fn conditional() -> bool { true }

fn main() {
    let mut guard = guard(Vec::new(), |mut v| v.clear());
    guard.push(1);
     
    if conditional() {
        // a condition maybe makes us decide to
        // “defuse” the guard and get back its inner parts
        let value = ScopeGuard::into_inner(guard);
    } else {
        // guard still exists in this branch
    }
}

Trait Implementations

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    T: Debug,
    F: FnOnce(T),
    S: Strategy, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, F, S> Deref for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy, 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, F, S> DerefMut for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy, 

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

Mutably dereferences the value.

impl<T, F, S> Drop for ScopeGuard<T, F, S> where
    F: FnOnce(T),
    S: Strategy, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F, S> Sync for ScopeGuard<T, F, S> where
    T: Sync,
    F: FnOnce(T),
    S: Strategy,