Struct Arriving 

pub struct Arriving<T, E = String> { /* private fields */ }

A read whose answer arrives later. Clones share one read.

Build the view with Self::view: it says what shows once the answer is there, and nothing about waiting.

Implementations

impl<T, E> Arriving<T, E>

pub fn ready(value: T) -> Arriving<T, E>

An answer already here.

pub fn pending(from: Source) -> Arriving<T, E>

A read asked now, its answer coming from from. Publish the answer through Self::writer or Self::begin.

pub fn pending_since(from: Source, since: Instant) -> Arriving<T, E>

A read asked at since, its answer coming from from: for a model that keeps when its read began and builds its view again meanwhile.

pub fn with<R>(&self, read: impl FnOnce(&Arrival<T, E>) -> R) -> R

Where the read stands, without exposing its lock.

pub fn get(&self) -> Arrival<T, E>

where T: Clone, E: Clone,

Where the read stands, cloned.

pub fn state(&self) -> LocalState<Arrival<T, E>>

The observable state, for crate::widget::ModelView, Text or a callback that needs the whole arrival.

pub fn revision(&self) -> u64

Advances with every change of the read, for a widget that skips work while nothing changed.

pub fn began(&self) -> Instant

When the read now pending was asked (or when the last one was).

pub fn clock(&self) -> Option<ArrivalClock>

The timing of the read now pending; None once it settled.

pub fn holds_frame_until(&self, now: Instant) -> Option<Instant>

Until when a frame showing this read waits for it at now: while it is a local read inside its frame budget.

pub fn can_retry(&self) -> bool

Whether a retry is offered when the read fails.

pub fn retry(&self)

Ask again after a failure, the way the read was first asked. A read that set no way to retry (Self::on_retry) ignores this.

pub fn on_retry( self, retry: impl Fn(&Arriving<T, E>) + Send + Sync + 'static, ) -> Arriving<T, E>

How to ask again after a failure: retry restarts the read on this handle (usually through Self::begin).

pub fn stand(&self, arrival: Arrival<T, E>)

Say where the read stands, from the thread that holds its data (a record the window follows), with no worker to publish through. A read that settled and is pending again was asked now; one still pending keeps when it was asked, now waiting on from.

impl<T, E> Arriving<T, E>

where T: Send + Sync + 'static, E: Send + Sync + 'static,

pub fn writer(&self) -> ArrivalWriter<T, E>

A handle for a producer that publishes more than one answer (an invocation’s updates, pages gathering). It does not restart the read: Self::begin does.

pub fn begin(&self, from: Source) -> ArrivalCompletion<T, E>

Restart the read, its answer now coming from from: every older completion becomes stale before the pending state is published.

pub fn load<F>(&self, from: Source, load: F) -> bool

where F: Future<Output = Result<T, E>> + Send + 'static,

Restart the read with load’s answer, run on the app runtime (tilo_rt::app), never on the calling thread. A later restart aborts it at its next await point.

pub fn local( name: &'static str, load: impl Fn() -> Result<T, E> + Send + Sync + 'static, ) -> Arriving<T, E>

where E: From<String>,

A read of this device’s data: load runs on a background worker (crate::background::Background) and a failure offers a retry that runs it again. A host that runs no background work fails it, saying so.

pub fn read_in_background( &self, name: &'static str, from: Source, load: Arc<dyn Fn() -> Result<T, E> + Send + Sync>, )

where E: From<String>,

Restart the read with load, run on a background worker, its answer coming from from.

impl<T, E> Arriving<T, E>

where T: 'static, E: Display + 'static,

pub fn view( &self, build: impl FnMut(&T) -> Box<dyn Widget> + 'static, ) -> ArrivingView

The view of this read: build’s content once the answer is there. Every placeholder and timing on the way is the framework’s (ArrivingView).

Trait Implementations

impl<T, E> Clone for Arriving<T, E>

fn clone(&self) -> Arriving<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, E> Debug for Arriving<T, E>

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

Formats the value using the given formatter.