Struct signalo_filters::sink::Integrate

pub struct Integrate<T> { /* fields omitted */ }

A sink that computes the integrate of all received values of a signal.

Example:

use signalo_filters::prelude::Source;
use signalo_filters::prelude::Sink;

use signalo_filters::source::Increment;
let increment: Increment<_> = Increment::new(0, 1);
// ╭───╮  ╭───╮  ╭───╮  ╭───╮  ╭───╮
// │ 0 │─▶│ 1 │─▶│ 2 │─▶│ 3 │─▶│ 4 │─▶ ...
// ╰───╯  ╰───╯  ╰───╯  ╰───╯  ╰───╯

use signalo_filters::source::Take;
let mut take: Take<_> = Take::new(increment, 3);
// ╭───╮  ╭───╮  ╭───╮
// │ 0 │─▶│ 1 │─▶│ 2 │
// ╰───╯  ╰───╯  ╰───╯

use signalo_filters::sink::Integrate;
let mut integrate = Integrate::default();
while let Some(value) = take.source() {
    integrate.sink(value);
}
assert_eq!(integrate.finalize(), Some(3));

Trait Implementations

impl<T: Clone> Clone for Integrate<T>

fn clone(&self) -> Integrate<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Default> Default for Integrate<T>

fn default() -> Integrate<T>

Returns the "default value" for a type.

impl<T: Debug> Debug for Integrate<T>

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

Formats the value using the given formatter.

impl<T> Sink<T> for Integrate<T> where     T: Copy + Num,

type Output = Option<T>

The sink's output type.

fn sink(&mut self, input: T)

Processes the input value.

fn finalize(self) -> Self::Output

Consumes self, returning an accumulated output.