Struct WithLastValue 

pub struct WithLastValue<T: ?Sized, V> { /* private fields */ }

Wrapper for keeping last produced value

Trait Implementations

impl<T: Clone + ?Sized, V: Clone> Clone for WithLastValue<T, V>

fn clone(&self) -> WithLastValue<T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ?Sized, V: Debug> Debug for WithLastValue<T, V>

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

Formats the value using the given formatter.

impl<T> Method for WithLastValue<T, T::Output>

where T: Method, T::Output: Debug + Clone,

type Params = <T as Method>::Params

Method parameters

type Input = <T as Method>::Input

Input value type

type Output = <T as Method>::Output

Output value type

fn new( parameters: Self::Params, initial_value: &Self::Input, ) -> Result<Self, Error>

Static method for creating an instance of the method with given parameters and initial value (simply first input value)

fn next(&mut self, value: &Self::Input) -> Self::Output

Generates next output value based on the given input value

fn with_history( parameters: Self::Params, initial_value: &Self::Input, ) -> Result<WithHistory<Self, Self::Output>, Error>

where Self: Sized, Self::Output: Debug + Clone,

Creates an instance of the method with given parameters and initial value, wrapped by historical data holder

fn with_last_value( parameters: Self::Params, initial_value: &Self::Input, ) -> Result<WithLastValue<Self, Self::Output>, Error>

where Self: Sized, Self::Output: Debug + Clone,

Creates an instance of the method with given parameters and initial value, wrapped by last produced value holder

fn name(&self) -> &str

Returns a name of the method

fn memsize(&self) -> (usize, usize)

where Self: Sized,

👎Deprecated

Returns memory size of the method (size, align)

fn over<S>(&mut self, inputs: S) -> Vec<Self::Output>

where S: Sequence<Self::Input>, Self::Input: Sized, Self: Sized,

Iterates the Method over the given inputs slice and returns Vec of output values.

fn apply<T, S>(&mut self, sequence: &mut S)

where S: Sequence<T> + AsMut<[T]> + ?Sized, Self: Method<Input = T, Output = T> + Sized,

Applies method to the sequence in-place.

fn new_over<S>( parameters: Self::Params, inputs: S, ) -> Result<Vec<Self::Output>, Error>

where S: Sequence<Self::Input>, Self::Input: Sized, Self: Sized,

Creates new Method instance and iterates it over the given inputs slice and returns Vec of output values.

fn new_apply<T, S>( parameters: Self::Params, sequence: &mut S, ) -> Result<(), Error>

where S: Sequence<T> + AsMut<[T]>, Self: Method<Input = T, Output = T> + Sized,

Creates new Method instance and applies it to the sequence.

fn into_fn<'a>( self, ) -> Box<dyn FnMut(&'a <Self as Method>::Input) -> <Self as Method>::Output>

where Self: Sized + 'static, Self::Input: 'static,

Creates a function from the Method instance

fn new_fn( params: Self::Params, initial_value: &Self::Input, ) -> Result<Box<dyn FnMut(&'_ <Self as Method>::Input) -> <Self as Method>::Output>, Error>

where Self: Sized + 'static,

Creates new function based on the method

impl<T, V: Clone> Peekable<V> for WithLastValue<T, V>

fn peek(&self) -> V

Peeks the very last value, produced by method or indicator