Struct QueryEngine 

pub struct QueryEngine { /* private fields */ }

The query of one query view: its local index, its remote sources, and what it has found so far.

Implementations

impl QueryEngine

pub fn new(kinds: Vec<KindDecl>) -> Self

An engine for items of kinds, which also order the groups. It runs remote requests on the executor current now and wakes the window it is made in when they answer.

pub fn set_local_source(&mut self, source: Option<Arc<dyn LocalSource>>)

Answer with source too, beside the local items; None stops. What it finds for the open query joins the rows after those shown.

pub fn with_remote(self, source: Arc<dyn RemoteSource>) -> Self

Ask source too, in a section below the local results.

pub fn with_background(self, background: Background) -> Self

Run remote requests on background instead (a test’s pumped executor).

pub fn kinds(&self) -> &[KindDecl]

The types the engine knows.

pub fn set_waker(&mut self, wake: WakeHandle)

Wake wake’s window when a remote answer arrives or a request falls due, in place of the one current when the engine was made.

pub fn sync_local(&mut self, items: impl IntoIterator<Item = Item>)

Take items as the app’s whole local set; only what changed is indexed again. The rows an open query shows follow the change where they stand: a row whose item changed shows it changed (liked now), a row whose item left or no longer matches goes, and nothing new comes in above the rows below it until the query changes. Liking a catalogue song in the results brings it and its album into the library, and neither may push the row the person just pressed from under the pointer.

Prose (Item::body) is indexed off the UI thread when the bodies change; the matches in it join the open query’s rows when it lands (Self::poll), after the rows shown.

pub fn warm(&mut self)

The person focused the search field: open the remote sources’ connections before the first character.

pub fn set_query(&mut self, query: QuerySpec) -> bool

Ask query. The local results are in Self::results when this returns; remote ones follow through Self::poll. Asking what is asked already changes nothing. Returns whether the results changed.

pub fn retry(&mut self, source: &str) -> bool

Ask remote source source again for the open query, after it could not answer: its section waits again, its placeholder timed from now. Whether it was asked.

pub fn facet_offers(&self) -> Vec<FacetOffer>

The open query’s filter chips, each value filter’s values counted among what the query finds without that filter’s own choice: the library searched again without it, and the remote rows shown.

pub fn close(&mut self)

Stop: every request is cancelled and nothing is shown.

pub fn is_open(&self) -> bool

pub fn results(&self) -> &QueryResults

What the query has found so far.

pub fn timings(&self) -> &QueryTimings

How long the open query took to show what it has.

pub fn hold(&mut self, held: bool)

Whether the person points at, or has the keyboard in, a remote section. While they do, arriving rows only go on at the end of what is shown; when they stop, a finished answer is laid out in its order.

pub fn poll(&mut self) -> bool

Send what is due and take in what arrived. Returns whether the results changed. Call every frame while a query is open; the engine wakes the window when something arrives or falls due.