Struct ScopeGuard 

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

Owns a value and conditionally passes it to an action when dropped.

The guarded value is accessible through Deref and DerefMut. The action receives ownership of the final value and runs at most once. Panics from the strategy or a drop-time action propagate. A second panic during unwinding may abort the process.

Implementations

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

where F: FnOnce(T), S: Strategy,

pub const fn with_strategy(value: T, action: F) -> Self

Creates an armed guard using strategy S.

pub fn into_inner(self) -> T

Disarms the guard and returns its value without running the action.

pub fn into_parts(self) -> (T, F)

Disarms the guard and returns both its value and action.

pub fn run_now(self)

Runs the action immediately, regardless of S, and consumes the guard.

Trait Implementations

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

where T: Debug, F: FnOnce(T), S: Strategy,

fn fmt(&self, formatter: &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) -> &Self::Target

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 Self::Target

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.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.