Enum Writes 

pub enum Writes<'a> {
    Offsets(&'a [usize]),
    Walk {
        base: usize,
        steps: &'a [Steps],
    },
}

Where a scatter writes: at flat offsets, or at the positions that steps reach from base, in the order walk reads them. A Steps::FILL offset, or a fill position, writes nothing. A walk writes without listing its positions.

Variants

Offsets(&'a [usize])

Walk

Fields

base: usize

steps: &'a [Steps]

Implementations

impl<'a> Writes<'a>

pub fn len(&self) -> usize

The number of writes, fills included.

pub fn is_empty(&self) -> bool

Whether there are no writes.

pub fn listed(&self) -> Cow<'a, [usize]>

The writes’ flat offsets, listing a walk’s positions (Steps::combined).

pub fn runs_while(&self, each: &mut dyn FnMut(usize, &[usize]) -> bool) -> bool

Calls each(k, run) with runs of the writes’ flat offsets, in order, where k is the place among the writes of the run’s first, until each gives false, and gives whether it went through every run. A fill gives Steps::FILL. Listed offsets are one run. A table of index values converts its own runs, as Table::chunks gives them. Other walks gather whole innermost axes into runs of about TABLE_CHUNK offsets (Steps::reached), so no walk is listed whole. each is a trait object, so the walk compiles once, and each caller’s loop over a run once.

pub fn only_fills(&self) -> bool

Whether every write is at a fill, which writes nothing, as having no writes does.

pub fn write<S, D>(self, out: &mut [D], items: &[S], conv: impl Convert<S, D>)

where S: Item, D: Item,

Replaces the item of out at each write with the matching item of items, converted by conv, or with its only item, through scatter or scatter_walk. A later write wins.

pub fn combine<D, S, E>( self, out: &mut [D], values: Arg<'_, S>, f: impl Fn(D, S) -> (D, Option<E>), ) -> Option<E>

where D: Copy, S: Copy, E: Copy,

Combines the matching item of values, or its only item, into the item of out at each write by f, in order, as out[o] = f(out[o], y).0. An out-of-range position writes nothing; a place that repeats combines again. With addition, this is the transpose of a gather that reads a position more than once. It gives the last failure that f reports.

Trait Implementations

impl<'a> Clone for Writes<'a>

fn clone(&self) -> Writes<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Writes<'a>

impl From<Writes<'_>> for Mapping

The mapping that reads the places that writes writes, in order: a list of offsets as one table, and a walk as its own steps.

fn from(writes: Writes<'_>) -> Mapping

Converts to this type from the input type.