Struct ScopeGuard

pub struct ScopeGuard<T, F: FnOnce(T, &S), S> { /* private fields */ }

A guard that executes a callback on drop, using an associated state.

Vendored

This is adapted work from stated-scope-guard.

Implementations

impl<T> ScopeGuard<T, fn(T, &bool), bool>

pub fn new<F: FnOnce(T)>( value: T, callback: F, ) -> ScopeGuard<T, impl FnOnce(T, &bool), bool>

Constructs a scope guard with a boolean state (defaulting to true).

The callback is executed on drop unless dismissed.

Example

let result = Cell::new(0);
{
    let _guard = ScopeGuard::new(10, |value| {
        result.set(value + 5);
    });
}
assert_eq!(result.get(), 15);

impl<T, F: FnOnce(T, &bool)> ScopeGuard<T, F, bool>

pub fn dismiss(&mut self)

Dismisses the callback for a boolean state guard.

Once dismissed, the callback won’t be executed on drop.

Example

let result = Cell::new(0);
{
    let mut guard = ScopeGuard::new(10, |value| {
        result.set(value + 5);
    });
    guard.dismiss();
}
assert_eq!(result.get(), 0);

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

pub fn with(value: T, state: S, callback: F) -> Self

Creates a scope guard with a custom state.

The guarded value is accessible via Deref and DerefMut.

Example

// A simple resource that requires cleanup.
struct Resource;
impl Resource {
    fn new() -> Self { Resource }
    /// Cleans up the resource using the given strategy, updating the flag accordingly.
    fn cleanup(&self, strategy: &Cleanup, flag: &Cell<&'static str>) {
        match strategy {
            Cleanup::Standard => flag.set("standard cleanup"),
            Cleanup::Alternate => flag.set("alternate cleanup"),
        }
    }
}
// Define different cleanup strategies.
enum Cleanup {
    Standard,
    Alternate,
}
let cleanup_flag = Cell::new("not cleaned");
{
    let mut guard = ScopeGuard::with(
        Resource::new(),
        Cleanup::Standard,
        |res, strategy| { res.cleanup(strategy, &cleanup_flag) }
    );
    // Perform operations that require changing the cleanup strategy.
    guard.set_state(Cleanup::Alternate);
} // When the guard goes out of scope, it triggers the cleanup callback.
assert_eq!(cleanup_flag.get(), "alternate cleanup");

pub fn set_state(&mut self, state: S)

Updates the current state.

Trait Implementations

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

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

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

fn drop(&mut self)

On drop, invokes the callback with the guarded value and a reference to the current state.