Struct ReconfigurableLiveQuery 

pub struct ReconfigurableLiveQuery<Q, T, E> { /* private fields */ }

A subscription whose request may be replaced while it runs. Its results fail with E, the query closure’s own error type.

Implementations

impl<Q, T, E> ReconfigurableLiveQuery<Q, T, E>

where Q: Clone + PartialEq + Send + Sync + 'static, T: Send + 'static, E: From<DbError> + CarriesBug + Send + 'static,

pub fn runs(&self) -> LiveQueryRuns

How often this query has run so far, its processed form’s runs too.

pub fn is_marked_for_rerun(&self) -> bool

Whether a commit since this idle query’s last result changes what it reads, so asking for its next result runs it again. A commit marks the queries it changes as it commits, so this answers with no waiting.

pub fn requests(&self) -> LiveQueryRequests<Q>

Obtain a cloneable handle for replacing this query’s request.

pub fn process<P, U>(self, process: P) -> ReconfigurableLiveQuery<Q, U, E>

where T: Clone + PartialEq, P: Fn(T) -> Result<U, E> + Send + Sync + 'static, U: Send + 'static,

Process each value on a worker after releasing the connection. Equality compares processed values; request handles and event metadata remain.

pub async fn next(&mut self) -> Option<ReconfigurableLiveQueryEvent<Q, T, E>>

where T: Clone + PartialEq,

Return the next result and its request. Cancelling this wait retains the in-flight run, so its request revision is not lost. Once the store is closed, or the handle fails every call, one result reports why and every later call returns None. So does a run whose error carries a bug, as one that panicked does with DbError::Bug: what it read is unknown, so no commit could tell whether to run it again (E15).