Struct moxie::embed::Runtime

pub struct Runtime<Root> { /* fields omitted */ }

The primary integration point between moxie and an embedding environment. Owns the cache and state for a moxie application. Each instance is independent.

Minimal Example

This example has no side effects in its root closure, and doesn't have any state variables which might require mutation wakeups.

let mut rt = Runtime::new(|| {});
assert_eq!(rt.revision().0, 0);
for i in 1..10 {
    rt.run_once();
    assert_eq!(rt.revision(), Revision(i));
}

Methods

impl<Root, Out> Runtime<Root> where
    Root: FnMut() -> Out, 

pub fn new(root: Root) -> Self

Construct a new Runtime with blank storage and no external waker or task executor.

By default the task executor used for load and its siblings is the same single-threaded one as the executor used for handler futures. It is strongly recommended that outside of testing users of this struct call set_task_executor with a reference to a more robust I/O- or compute-oriented executor.

pub fn oneshot(root: Root) -> Out

Constructs a new Runtime, runs the provided root once, and returns the result.

pub fn revision(&self) -> Revision

The current revision of the runtime, or how many times run_once has been invoked.

pub fn run_once(&mut self) -> Out

Runs the root closure once with access to memoization storage, increments the runtime's Revision, and drops any memoized values which were not marked Liveness::Live.

pub fn run_until_ready(&mut self, filter: impl FnMut(Out) -> Poll<Out>) -> Out

Calls run_once in a loop until filter returns Poll::Ready, returning the result of that Revision.

pub fn run_until_at_least_revision(&mut self, rev: Revision) -> Out

Calls run_once in a loop until the runtime's revision is equal to the one provided.

Always calls run_once at least once.

pub fn set_state_change_waker(&mut self, wk: Waker) -> &mut Self

Sets the std::task::Waker which will be called when state variables receive commits. By default the runtime no-ops on a state change, which is probably the desired behavior if the embedding system will call Runtime::run_once on a regular interval regardless.

pub fn set_task_executor(&mut self, sp: impl LocalSpawn + 'static) -> &mut Self

Sets the executor that will be used to spawn normal priority tasks.