Struct ScopeGuard

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

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.

Implementations

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

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.

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

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

type Target = T;
fn deref(&self) -> &T

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

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

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

fn drop(&mut self)

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

Auto Trait Implementations

impl<T, F, S> Freeze for ScopeGuard<T, F, S> where ManuallyDrop<T>: Freeze, ManuallyDrop<F>: Freeze, PhantomData<fn(S) -> S>: Freeze,

impl<T, F, S> RefUnwindSafe for ScopeGuard<T, F, S> where ManuallyDrop<T>: RefUnwindSafe, ManuallyDrop<F>: RefUnwindSafe, PhantomData<fn(S) -> S>: RefUnwindSafe,

impl<T, F, S> Send for ScopeGuard<T, F, S> where ManuallyDrop<T>: Send, ManuallyDrop<F>: Send, PhantomData<fn(S) -> S>: Send,

impl<T, F, S> Unpin for ScopeGuard<T, F, S> where ManuallyDrop<T>: Unpin, ManuallyDrop<F>: Unpin, PhantomData<fn(S) -> S>: Unpin,

impl<T, F, S> UnsafeUnpin for ScopeGuard<T, F, S> where ManuallyDrop<T>: UnsafeUnpin, ManuallyDrop<F>: UnsafeUnpin, PhantomData<fn(S) -> S>: UnsafeUnpin,

impl<T, F, S> UnwindSafe for ScopeGuard<T, F, S> where ManuallyDrop<T>: UnwindSafe, ManuallyDrop<F>: UnwindSafe, PhantomData<fn(S) -> S>: UnwindSafe,

Blanket Implementations

impl<P, T> Receiver for ScopeGuard<T, F, S> where P: Deref<Target = T> + ?Sized, T: ?Sized,

type Target = T;

impl<T> Any for ScopeGuard<T, F, S> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for ScopeGuard<T, F, S> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for ScopeGuard<T, F, S> where T: ?Sized,

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

impl<T> From<T> for ScopeGuard<T, F, S>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for ScopeGuard<T, F, S> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for ScopeGuard<T, F, S> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for ScopeGuard<T, F, S> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>