Struct GridWriter 

pub struct GridWriter<R: GridRow> { /* private fields */ }

Writes rows into a GridStore from any thread.

Operations are applied in order by the store’s ingest task. Writing is a short lock and a non-blocking wake-up; it never waits for the UI. Operations written one by one may be published in different snapshots; GridWriter::batch publishes several in one.

Implementations

impl<R: GridRow> GridWriter<R>

pub fn batch(&self, write: impl FnOnce(&mut WriteBatch<R>))

Writes the operations of write as one batch: the store applies them in order and publishes them in one snapshot, so no snapshot has some of them without the others. Other writes may share that snapshot. Nothing is written until write returns; then the batch costs one lock and at most one wake-up.

A running reload buffers the batch’s writes until it finishes, as it buffers single ones, but not the batch’s progress, which is never buffered. WriteBatch::finish_reload finishes a reload inside the batch: the reloaded rows and the batch’s writes after it, such as clearing the progress, are published together.

writer.batch(|batch| {
    batch.finish_reload(reload, rows);
    batch.set_progress(None);
});

pub fn begin_reload(&self) -> Reload<R>

Starts a reload: until Reload::finish, operations from every writer are buffered instead of applied. finish(snapshot) hands the snapshot and the buffered operations to the store’s ReloadPolicy (by default the snapshot replaces every row and the buffered operations are replayed on top). Dropping the guard without finish cancels the reload and applies the buffered operations as usual. A newer reload supersedes an older one: the older finish is then ignored.

pub fn upsert(&self, row: impl Into<Arc<R>>)

Inserts or replaces a row by key and highlights the changed columns, each with its GridRow::change_direction.

A new row that changes no column is published all the same, without highlight, so hooks that read other data of the row see it. Writing the same Arc again changes nothing.

pub fn upsert_silent(&self, row: impl Into<Arc<R>>)

Inserts or replaces a row by key without highlight.

pub fn mark_changed(&self, key: R::Key, columns: ColumnSet)

Highlights columns of an existing row without replacing it, without a direction: the values did not change.

pub fn remove(&self, key: R::Key)

Removes a row by key. With a removal fade (HighlightPolicy::with_removal_fade), its last version stays in snapshots as a fading row (StoreSnapshot::fading_row) until the fade ends or the key is written again.

pub fn replace_all(&self, rows: impl IntoIterator<Item = Arc<R>>)

Atomically replaces every row, without highlight.

pub fn clear(&self)

Removes every row.

pub fn set_pinned_rows( &self, edge: PinnedEdge, rows: impl IntoIterator<Item = Arc<R>>, )

Replaces the rows pinned at edge (an empty rows clears the band).

Applied in order with other writes; buffered by a running reload like them. Rows are diffed by key against the previous band: changed columns are highlighted and a new key flashes, except on the first fill of an empty band. A key repeated within rows keeps its last row. Pinned keys are a space of their own, apart from the data rows and the other band. replace_all and clear leave bands alone.

pub fn set_progress(&self, progress: Option<GridProgress>)

Shows (Some) or clears (None) the store’s progress.

Applied in order with other writes, but never buffered by a reload: progress written during a reload shows while the reload runs, and progress cleared after Reload::finish is never cleared before the snapshot that applies the reload. It may be cleared in a later one; to clear it in that very snapshot, write both in one GridWriter::batch with WriteBatch::finish_reload.

pub fn flush(&self) -> impl Future<Output = Option<u64>> + Send + 'static

Resolves once every operation written before the call is applied and published: with that store version (the version of the published snapshot that has them), or None if the store is gone.

The operations waited for are fixed by the call, not by the first poll. Operations buffered by an unfinished reload are not waited for: they are not written to the store until Reload::finish. Each call wakes the ingest task once; an idle store resolves with its current version.

pub fn is_closed(&self) -> bool

Returns true once the store is gone; producers can stop writing.

pub fn snapshot(&self) -> Arc<StoreSnapshot<R>>

The latest published snapshot, for producers that need the current rows (e.g. to patch a row by key). Operations still queued are not in it.

Trait Implementations

impl<R: GridRow> Clone for GridWriter<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.