Struct Walk 

pub struct Walk {
    pub base: usize,
    pub steps: Vec<Steps>,
    pub along: Vec<Option<usize>>,
    pub strides: Vec<usize>,
}

How a copy walks its source: one entry for each axis of the copy, the source axis that each entry walks, and the offset of the positions on source axes that no entry walks. Axes that walk one source axis together read windows, as Windows::plan lays them out. Every reader of windows from Steps classifies them here: Walk::read gives what the axes along one source axis read.

Fields

base: usize

The offset of the positions on source axes that no entry walks.

steps: Vec<Steps>

One entry for each axis of the copy. The first entry along each walked axis holds that axis’s position in its start.

along: Vec<Option<usize>>

The source axis that each entry walks, or None for an entry whose offsets are all 0, as for an axis of one item or a spread.

strides: Vec<usize>

The source’s strides.

Implementations

impl Walk

pub fn new(tables: &[Steps], shape: &[usize], source: &[usize]) -> Option<Walk>

The walk that tables give for a copy of shape from a source of shape source. None where an entry doesn’t walk one source axis, where a walked axis’s position can’t move into the start of a Stride, as for a Padded or Rotated entry over part of an axis, and where the source is empty.

pub fn walking(&self, a: usize) -> impl Iterator<Item = usize>

The axes of the copy that walk source axis a, in order.

pub fn read(&self, a: usize, n: usize) -> Option<(usize, Vec<[usize; 2]>)>

What the entries walking source axis a, of n items, read as windows, such as a copy’s frames and the positions in each window: where the windows start, and each entry’s length and move in positions. Each entry must be a Stride that steps forward by a whole number of positions. An axis that no entry walks reads position 0. None for any other entries, and where the windows don’t lie inside the axis.

pub fn windows(&self, source: &[usize]) -> Option<Vec<[usize; 3]>>

The leading windows read by this copy, as [number, width, step] per axis. The copy’s axes must be frames, windows, then unchanged source axes. Each frame starts at 0.

pub fn transpose_windows( &self, source: &[usize], ) -> Option<(Vec<usize>, Vec<Mapping>)>

The transpose of unit-step leading windows as an axis order and copies to sum. The copies read the reordered windows back to the source, with zero at missing positions.

Trait Implementations

impl Clone for Walk

fn clone(&self) -> Walk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Walk

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

Formats the value using the given formatter.