Struct Major 

pub struct Major<P: ?Sized, U> {
    pub inner: P,
    /* private fields */
}

Chain of major processors with intermediate buffer supporting block() processing from individual block()s

Prefer default composition for X->X->X, arrays/slices where inplace is possible

Fields

inner: P

The inner processors

Implementations

impl<P, U> Major<P, U>

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

Create a new chain of processors

Trait Implementations

impl<P: Clone + ?Sized, U: Clone> Clone for Major<P, U>

fn clone(&self) -> Major<P, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug + ?Sized, U: Debug> Debug for Major<P, U>

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

Formats the value using the given formatter.

impl<P: Default + ?Sized, U: Default> Default for Major<P, U>

fn default() -> Major<P, U>

Returns the “default value” for a type.

impl<X: Copy, U: Copy + Default, C0, C1, S0, S1, const N: usize> SplitInplace<X, (S0, S1)> for Major<(C0, C1), [U; N]>

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

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

See also Inplace::inplace

impl<X: Copy, U: Copy + Default, Y, C0, C1, S0, S1, const N: usize> SplitProcess<X, Y, (S0, S1)> for Major<(C0, C1), [U; N]>

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 (S0, S1), x: &[X], y: &mut [Y])

Process a block of inputs

impl<P: Copy + ?Sized, U: Copy> Copy for Major<P, U>