Struct scopeguard::ScopeGuard
[−]
[src]
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
[src]
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)
[src]
type Target = T
The resulting type after dereferencing
fn deref(&self) -> &T
The method called to dereference a value
impl<T, F, S: Strategy> DerefMut for ScopeGuard<T, F, S> where F: FnMut(&mut T)
[src]
fn deref_mut(&mut self) -> &mut T
The method called to mutably dereference a value