Struct AppRuntime 

pub struct AppRuntime { /* private fields */ }

The process-wide app runtime: a current-thread tokio runtime driven by a dedicated thread.

One thread is enough for an app: its async work is network and IPC waiting, not computation. CPU-bound work goes to crate::cpu() and blocking calls to AppRuntime::spawn_blocking, so neither stalls the other tasks.

The runtime starts on first use and lives as long as the process.

Implementations

impl AppRuntime

pub const fn handle(&self) -> &Handle

The runtime’s handle, for APIs that take one or need a runtime context (handle().enter()) to construct I/O resources.

pub const fn thread_id(&self) -> ThreadId

The thread that drives this runtime.

pub fn is_runtime_thread(&self) -> bool

Whether the calling thread is the one driving this runtime.

pub fn spawn<F>(&self, future: F) -> JoinHandle<<F as Future>::Output>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static,

Run future on the runtime thread. Returns immediately; the caller never polls it.

pub fn spawn_then<F, D>(&self, future: F, deliver: D) -> JoinHandle<()>

where F: Future + Send + 'static, <F as Future>::Output: Send + 'static, D: FnOnce(<F as Future>::Output) + Send + 'static,

Run future on the runtime thread, then hand its output to deliver there. deliver should only publish — complete a LatestRequest, send on a channel — so the runtime thread is free for the next task. This is the UI handoff: the UI thread spawns, and deliver wakes the event loop with the result.

pub fn spawn_pinned<M, F>(&self, make: M) -> JoinHandle<<F as Future>::Output>

where M: FnOnce() -> F + Send + 'static, F: Future + 'static, <F as Future>::Output: Send + 'static,

Run the future make builds, where the future may hold values that stay on one thread (a browser page’s storage handles, where that is the target): natively it is built and driven on one thread of the blocking pool, with the runtime’s drivers.

pub fn spawn_blocking<F, R>(&self, call: F) -> JoinHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Run a blocking call on the runtime’s bounded blocking pool.

pub fn block_on<F>(&self, future: F) -> Result<<F as Future>::Output, Error>

where F: Future,

Wait on future from a synchronous thread.

For threads that own a blocking API (a git transport callback, a decoder loop, a synchronous library entry point) and need one async result. The caller polls future itself — so it may borrow — while the runtime thread drives its sockets and timers and runs anything it spawns. No runtime is built per call.

Errors

Error::UiThread on a UI thread, Error::InsideRuntime from a runtime context, where waiting would stall the tasks that thread is meant to run.

Trait Implementations

impl Debug for AppRuntime

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

Formats the value using the given formatter.