Struct deferred::deferred_manager::DeferredManager

pub struct DeferredManager<S> { /* private fields */ }

Deferred execution manager used to store and resume.

Implementations

impl<S> DeferredManager<S>

pub fn new() -> Self

Creates new deferred execution manager.

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.resume_all();
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

pub fn count(&self) -> usize

Gets number of deferred executions currently waiting to resume.

pub fn run(&mut self, deferred: Deferred<S>) -> Id

Register deferred logic for later execution.

Arguments

• deferred - deferred execution unit.

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.resume_all();
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

pub fn cancel(&mut self, id: Id) -> bool

Creates new deferred execution manager.

Arguments

• id - deferred execution id (got from calling run() method).

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.cancel(id);
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), false);

pub fn resume(&mut self, id: Id) -> bool

Resume specified deferred execution unit by its id.

Arguments

• id - deferred execution id (got from calling run() method).

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.resume(id);
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

pub fn consume(&mut self, id: Id) -> Option<S>

Consume specified deferred execution unit by its id and return its state.

Arguments

• id - deferred execution id (got from calling run() method).

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.consume(id).unwrap();
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

pub fn has(&self, id: Id) -> bool

Tells if deferred execution unit with given id currently waits for later execution.

Arguments

• id - deferred execution id (got from calling run() method).

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
manager.resume_all();
assert_eq!(manager.has(id), false);

pub fn resume_all(&mut self)

Resume sall deferred execution units.

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.resume_all();
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

pub fn consume_all(&mut self) -> Vec<(Id, S)>

Consume all deferred execution units and return vector of id-state pairs.

Example

use std::rc::Rc;
use std::cell::Cell;

type RcBool = Rc<Cell<bool>>;

fn foo(v: RcBool) -> Deferred<Value> {
    deferred!(value!(v), [
        |c| {
            let v = c.state().consume::<RcBool>();
            v.set(true);
            state!(value!(v))
        }
    ])
}

let mut manager = DeferredManager::new();
let status = Rc::new(Cell::new(false));
let id = manager.run(foo(status.clone()));
assert_eq!(manager.has(id), true);
assert_eq!(status.get(), false);
manager.consume_all();
assert_eq!(manager.has(id), false);
assert_eq!(status.get(), true);

Trait Implementations

impl<S> Default for DeferredManager<S>

fn default() -> Self

Returns the “default value” for a type.