Struct WakeHandle 

pub struct WakeHandle { /* private fields */ }

Captures one scope, or remains detached forever. Unlike a closed scope, detached execution may publish local/headless state without waking a host.

Implementations

impl WakeHandle

pub fn new() -> WakeHandle

pub const fn detached() -> WakeHandle

pub fn is_active(&self) -> bool

pub fn wake(&self)

pub fn wake_save_progress(&self)

Wake the owner because a record’s save moved on (a write landed or failed), and for nothing else. An owner that cannot tell wakes apart takes it as Self::wake; one that can shows the save status alone, without running its model again for a write that changed nothing it holds.

pub fn owe(&self) -> Owed

Owe the owner a reply: work it asked for off its thread whose answer it waits to take up, such as a worker’s reply to a request. The work holds the Owed and drops it once its answer is queued for the owner (or it ends without one), which wakes the owner.

What an action causes this way is part of the action: a host answers the action once every reply owed meanwhile landed and was taken up (Self::settle), so its effects are the action’s, not the next one’s. Owe only short work answered by itself: long-running work an action starts answers as a job instead, and nothing waits on a person (a chooser) or on a stream that does not end. A detached handle, or one whose scope closed, owes nothing.

pub fn owes(&self) -> bool

Whether a reply is owed to the scope that has not landed.

pub fn begin_pass(&self)

Forget the replies that landed so far: the owner’s next pass takes them up, and Self::settled after it asks only about later ones. For an owner that cannot wait (Self::settle), such as a window whose frames also serve a person: it marks where a pass begins and asks once it ended.

pub fn settled(&self) -> bool

Whether nothing is owed and no reply landed since Self::begin_pass: a pass that began after it took up everything that was owed. A closed or detached scope is settled; one that is not is woken when a reply lands, so its owner asks again then.

pub fn settle(&self, pass: impl FnMut())

Run pass, one turn of the owner’s loop that takes up whatever has landed for it, until no reply is owed (Self::owe) and a pass ran after the last one landed. Between passes it waits for the scope to be woken: it never polls, and returns at once when the scope closes. At least one pass runs: the one that takes up what the caller just did. A detached handle runs that one.

Trait Implementations

impl Clone for WakeHandle

fn clone(&self) -> WakeHandle

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WakeHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for WakeHandle

fn default() -> WakeHandle

Returns the “default value” for a type.