Crate scope_guard

Simple RAII scope guard

Usage:

No argument guard

use scope_guard::scope_guard;

let mut is_run = false;
{
     scope_guard!(|| {
         is_run = true;
     });
}
assert!(is_run);

Single argument guard

use scope_guard::scope_guard;

fn do_stuff(val: &mut u32)  {
    let old_val = *val;
    let mut val = scope_guard!(|val| {
        *val = old_val;
    }, val);

    **val += 1; //Double * to deref &mut u32

    let is_ok = false;//doing some computations
    if is_ok {
        val.forget();
    }
}

let mut val = 0;
do_stuff(&mut val);
assert_eq!(val, 0);

let mut guard = scope_guard!(|val| {
    *val = 1;
}, &mut val);
drop(guard);
assert_eq!(val, 1);

Stacked destructor calls

use scope_guard::scope_guard;

fn do_stuff(val: &mut u32)  {
    let old_value = *val;
    let val = scope_guard!(|val| {
        assert_eq!(*val, old_value);
        //Do nothing
    }, val);

    let mut val = val.stack(|val| {
        **val = old_value;
    });

    **val += 1; //Double * to deref &mut u32
}

let mut val = 0;
do_stuff(&mut val);
assert_eq!(val, 0);

Multiple argument guard

use scope_guard::scope_guard;

fn do_stuff(val: &mut u32, is_run: &mut bool)  {
    let old_val = *val;
    let mut guard = scope_guard!(|(val, is_run)| {
        *val = old_val;
        *is_run = false;
    }, val, is_run);

    *guard.0 += 1;
    *guard.1 = true;

    let is_ok = false; //doing some computations
    if is_ok {
        let (_val, _is_run) = guard.into_inner(); //analogues to forget
    }
}

let mut is_run = false;
let mut val = 0;
do_stuff(&mut val, &mut is_run);
assert_eq!(val, 0);
assert!(!is_run);

let mut guard = scope_guard!(|(val, is_run)| {
    *val = 1;
    *is_run = true;
}, &mut val, &mut is_run);

drop(guard);
assert_eq!(val, 1);
assert!(is_run);

Macros

• scope_guard
  Creates scope guard, allowing to supply plain function with arguments in addition to closures.

Structs

• CatchUnwindFut
  Wraps to propagate panic as error.
• Scope
  RAII Scope, running closure in destructor.

Functions

• async_scope
  Executes future, making sure to perform cleanup regardless of whether fut is successful or panics.