Struct Minor 

#[repr(transparent)]
pub struct Minor<C: ?Sized, U> {
    pub inner: C,
    /* private fields */
}

Processor-minor, data-major

The various Process tooling implementations for Minor place the data loop as the outer-most loop (processor-minor, data-major). This is optimal for processors with small or no state and configuration.

Chain of large processors are implemented through native tuples and slices/arrays or Major. Those optimize well if the sizes obey configuration ~ state > data. If they do not, use Minor.

Note that the major implementations only override the behavior for block() and inplace(). process() is unaffected and the same for all.

Fields

inner: C

The inner configurations

Implementations

impl<C, U> Minor<C, U>

pub const fn new(inner: C) -> Self

Create a new chain

Trait Implementations

impl<C: Clone + ?Sized, U: Clone> Clone for Minor<C, U>

fn clone(&self) -> Minor<C, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug + ?Sized, U: Debug> Debug for Minor<C, U>

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

Formats the value using the given formatter.

impl<C: Default + ?Sized, U: Default> Default for Minor<C, U>

fn default() -> Minor<C, U>

Returns the “default value” for a type.

impl<X: Copy, U, C, S> SplitInplace<X, S> for Minor<C, U>

where Self: SplitProcess<X, X, S>,

fn inplace(&self, state: &mut S, xy: &mut [X])

See also Inplace::inplace

impl<X: Copy, C, S> SplitProcess<X, X, [S]> for Minor<[C], X>

where C: SplitProcess<X, X, S>,

A chain of multiple small filters of the same type

fn process(&self, state: &mut [S], x: X) -> X

Process an input into an output

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs

impl<X: Copy, Y: Copy, C, S, const N: usize> SplitProcess<X, Y, [S; N]> for Minor<[C; N], Y>

where C: SplitProcess<X, Y, S> + SplitProcess<Y, Y, S>,

A chain of multiple small filters of the same type

fn process(&self, state: &mut [S; N], x: X) -> Y

Process an input into an output

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs

impl<X: Copy, U: Copy, Y, C0, C1, S0, S1> SplitProcess<X, Y, (S0, S1)> for Minor<(C0, C1), U>

where C0: SplitProcess<X, U, S0>, C1: SplitProcess<U, Y, S1>,

fn process(&self, state: &mut (S0, S1), x: X) -> Y

Process an input into an output

fn block(&self, state: &mut S, x: &[X], y: &mut [Y])

Process a block of inputs

impl<C: Copy + ?Sized, U: Copy> Copy for Minor<C, U>