Struct scopeguard::ScopeGuard

pub struct ScopeGuard<T, F, S: Strategy = Always> where
    F: FnMut(&mut T),  { /* 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 a mut ref to the held value in the destructor. It's called only once.

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

Methods

impl<T, F, S> ScopeGuard<T, F, S> where
    F: FnMut(&mut 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.

Trait Implementations

impl<T, F, S: Strategy> Deref for ScopeGuard<T, F, S> where
    F: FnMut(&mut T), 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, F, S: Strategy> DerefMut for ScopeGuard<T, F, S> where
    F: FnMut(&mut T), 

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

Mutably dereferences the value.

impl<T, F, S: Strategy> Drop for ScopeGuard<T, F, S> where
    F: FnMut(&mut T), 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, F, S> Debug for ScopeGuard<T, F, S> where
    T: Debug,
    F: FnMut(&mut T),
    S: Strategy + Debug, 

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

Formats the value using the given formatter.