Struct Rebuild 

pub struct Rebuild { /* private fields */ }

Full filter, quick filter and sort of the whole snapshot.

A large snapshot is split across threads: each thread takes rows in chunks, keeps the visible ones and sorts them, and the sorted runs are merged. Every row has its own insertion sequence, the last sort key, so the order is the same on any number of threads. By default a rebuild leaves two cores to the UI thread and ingest and uses at most eight (Self::with_max_threads changes that). On wasm and for small snapshots it runs on the calling thread alone.

Implementations

impl Rebuild

pub fn with_max_threads(self, threads: usize) -> Self

Splits a rebuild across at most threads threads, the calling one included: 1 rebuilds on the calling thread alone, and 0 counts as 1. Each thread still takes at least 8192 rows, so a small snapshot stays on one thread whatever the count. The count is used as given: neither the cores of the machine nor the default’s limit of eight cap it. On wasm a rebuild always runs on the calling thread.

The default is the available cores less two (for the UI thread and ingest), at least one and at most eight.

pub fn max_threads(&self) -> usize

The most threads one rebuild uses, the calling one included: the count given to Self::with_max_threads, or the default budget. Always 1 on wasm.

Trait Implementations

impl Clone for Rebuild

fn clone(&self) -> Rebuild

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rebuild

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

Formats the value using the given formatter.

impl Default for Rebuild

fn default() -> Rebuild

Returns the “default value” for a type.

impl<R: GridRow> ProjectionEngine<R> for Rebuild

fn rebuild(&self, snapshot: &StoreSnapshot<R>, spec: &ViewSpec<R>) -> Projection

Builds the display order of snapshot for spec.

fn compact( &self, previous: &Projection, snapshot: &StoreSnapshot<R>, ) -> Projection

Drops rows removed since previous was built. Removing rows never reorders the rest and never makes a filtered-out row visible, so this is an O(n) filter, with no sorting. With groups it also recounts them, drops the emptied ones and lays the lines out again with each group’s expansion; the aggregate job (Self::aggregate) refreshes the aggregates.

fn aggregate( &self, previous: &Projection, snapshot: &StoreSnapshot<R>, spec: &ViewSpec<R>, ) -> Projection

The order of previous with fresh aggregates and row counts from snapshot. Neither reorders nor drops rows: Self::compact drops removed ones. Groups combine their subgroups in key order, as a rebuild does, so over the same order the result is the rebuild’s.

fn expand( &self, previous: &Projection, snapshot: &StoreSnapshot<R>, spec: &ViewSpec<R>, ) -> Projection

The order of previous laid out for spec.expansion(). The snapshot resolves the keys of tree rows: a tree is expanded by key.

impl Copy for Rebuild