Struct sampara::signal::Inspect

pub struct Inspect<S, F, const N: usize> where
    S: Signal<N>,
    F: FnMut(&S::Frame),  { /* fields omitted */ }

Creates a new Signal that calls a function with each Frame, and then yields the Frame.

Trait Implementations

impl<S: Clone, F: Clone, const N: usize> Clone for Inspect<S, F, N> where
    S: Signal<N>,
    F: FnMut(&S::Frame), 

fn clone(&self) -> Inspect<S, F, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, F, const N: usize> Signal<N> for Inspect<S, F, N> where
    S: Signal<N>,
    F: FnMut(&S::Frame), 

type Frame = S::Frame

The Frame type returned by this Signal.

fn next(&mut self) -> Option<Self::Frame>

Advances Self and returns the next Frame, or None if there are no more to yield.

fn sig_next(&mut self) -> Self::Frame

Similar to [next], but will always yield a Frame. Yields Frame::EQUILIBRIUM if there are no more actual Frames to yield.

fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Borrows this Signal rather than consuming it.

fn map<F, M, const NF: usize>(self, func: M) -> Map<Self, F, M, N, NF> where
    Self: Sized,
    F: Frame<NF>,
    M: FnMut(Self::Frame) -> F, 

Creates a new Signal that applies a function to each Frame of Self.

fn zip_map<O, F, M, const NO: usize, const NF: usize>(
    self,
    other: O,
    func: M
) -> ZipMap<Self, O, F, M, N, NO, NF> where
    Self: Sized,
    O: Signal<NO>,
    F: Frame<NF>,
    M: FnMut(Self::Frame, O::Frame) -> F, 

Creates a new Signal that applies a function to each pair of Frames in Self and another Signal.

fn add_signal<B>(self, other: B) -> AddSignal<Self, B, N> where
    Self: Sized,
    B: Signal<N>,
    Self::Frame: Frame<N, Signed = <B::Frame as Frame<N>>::Signed>, 

Creates a new Signal that yields the sum of pairs of Frames yielded by Self and another Signal in lockstep.

fn mul_signal<B>(self, other: B) -> MulSignal<Self, B, N> where
    Self: Sized,
    B: Signal<N>,
    Self::Frame: Frame<N, Float = <B::Frame as Frame<N>>::Float>, 

Creates a new Signal that yields the product of pairs of Frames yielded by Self and another Signal in lockstep.

fn add_frame<F>(self, frame: F) -> AddFrame<Self, F, N> where
    Self: Sized,
    Self::Frame: Frame<N, Signed = F>,
    F: Frame<N>, 

Creates a new Signal that yields each Frame of a Signal summed with a constant Frame.

fn mul_frame<F>(self, frame: F) -> MulFrame<Self, F, N> where
    Self: Sized,
    Self::Frame: Frame<N, Float = F>,
    F: Frame<N>, 

Creates a new Signal that yields each Frame of a Signal multiplied with a constant Frame.

fn add_amp<X>(self, amp: X) -> AddAmp<Self, X, N> where
    Self: Sized,
    Self::Frame: Frame<N>,
    <Self::Frame as Frame<N>>::Sample: Sample<Signed = X>,
    X: Sample, 

Creates a new Signal that yields each Frame of a Signal with each channel summed with a constant Sample.

fn mul_amp<X>(self, amp: X) -> MulAmp<Self, X, N> where
    Self: Sized,
    Self::Frame: Frame<N>,
    <Self::Frame as Frame<N>>::Sample: Sample<Float = X>,
    X: Sample, 

Creates a new Signal that yields each Frame of a Signal with each channel multiplied with a constant Sample.

fn delay(self, n_frames: usize) -> Delay<Self, N> where
    Self: Sized, 

Delays Self by a given number of frames. The delay is performed by yielding Frame::EQUILIBRIUM that number of times before continuing to yield frames from Self.

fn inspect<F>(self, func: F) -> Inspect<Self, F, N> where
    Self: Sized,
    F: FnMut(&Self::Frame), 

Calls an inspection function on each Frame yielded by this Signal, and then passes the Frame through.

fn take(self, n: usize) -> Take<Self, N> where
    Self: Sized, 

Returns a new Signal that yields only the first N Frames of Self.

fn into_iter(self) -> IntoIter<Self, N> where
    Self: Sized, 

Converts this Signal into an Iterator yielding Frames.