Struct sample::signal::BranchRefB

pub struct BranchRefB<'a, S: 'a, D: 'a> { /* fields omitted */ }

One of the two Branch signals returned by Fork::by_ref.

Methods

impl<'a, S, D> BranchRefB<'a, S, D> where     D: Slice,     D::Element: Copy,

pub fn pending_frames(&self) -> usize

The number of frames that are pending collection by this branch.

Trait Implementations

impl<'a, S, D> Signal for BranchRefB<'a, S, D> where     S: 'a + Signal,     D: 'a + SliceMut<Element = S::Frame>,

type Frame = S::Frame

The Frame type returned by the Signal.

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

Yield the next Frame in the Signal.

fn is_exhausted(&self) -> bool

Whether or not the signal is exhausted of meaningful frames.

fn map<M, F>(self, map: M) -> Map<Self, M, F> where     Self: Sized,     M: FnMut(Self::Frame) -> F,     F: Frame,

A signal that maps one set of frames to another.

fn zip_map<O, M, F>(self, other: O, map: M) -> ZipMap<Self, O, M, F> where     Self: Sized,     M: FnMut(Self::Frame, O::Frame) -> F,     O: Signal,     F: Frame,

A signal that maps one set of frames to another.

fn add_amp<S>(self, other: S) -> AddAmp<Self, S> where     Self: Sized,     S: Signal,     S::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>,

Provides an iterator that yields the sum of the frames yielded by both other and self in lock-step.

fn mul_amp<S>(self, other: S) -> MulAmp<Self, S> where     Self: Sized,     S: Signal,     S::Frame: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>,

Provides an iterator that yields the product of the frames yielded by both other and self in lock-step.

fn offset_amp(     self,     offset: <<Self::Frame as Frame>::Sample as Sample>::Signed ) -> OffsetAmp<Self> where     Self: Sized,

Provides an iterator that offsets the amplitude of every channel in each frame of the signal by some sample value and yields the resulting frames.

fn scale_amp(     self,     amp: <<Self::Frame as Frame>::Sample as Sample>::Float ) -> ScaleAmp<Self> where     Self: Sized,

Produces an Iterator that scales the amplitude of the sample of each channel in every Frame yielded by self by the given amplitude.

fn offset_amp_per_channel<F>(self, amp_frame: F) -> OffsetAmpPerChannel<Self, F> where     Self: Sized,     F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Signed, NumChannels = <Self::Frame as Frame>::NumChannels>,

Produces a new Signal that offsets the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn scale_amp_per_channel<F>(self, amp_frame: F) -> ScaleAmpPerChannel<Self, F> where     Self: Sized,     F: Frame<Sample = <<Self::Frame as Frame>::Sample as Sample>::Float, NumChannels = <Self::Frame as Frame>::NumChannels>,

Produces a new Signal that scales the amplitude of every Frame in self by the respective amplitudes in each channel of the given amp_frame.

fn mul_hz<M, I>(self, interpolator: I, mul_per_frame: M) -> MulHz<Self, M, I> where     Self: Sized,     M: Signal<Frame = [f64; 1]>,     I: Interpolator,

Multiplies the rate at which frames of self are yielded by the given signal.

fn from_hz_to_hz<I>(     self,     interpolator: I,     source_hz: f64,     target_hz: f64 ) -> Converter<Self, I> where     Self: Sized,     I: Interpolator,

Converts the rate at which frames of the Signal are yielded using interpolation.

fn scale_hz<I>(self, interpolator: I, multi: f64) -> Converter<Self, I> where     Self: Sized,     I: Interpolator,

Multiplies the rate at which frames of the Signal are yielded by the given value.

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

Delays the Signal by the given number of frames.

fn into_interleaved_samples(self) -> IntoInterleavedSamples<Self> where     Self: Sized,

Converts a Signal into a type that yields the interleaved Samples.

fn clip_amp(     self,     thresh: <<Self::Frame as Frame>::Sample as Sample>::Signed ) -> ClipAmp<Self> where     Self: Sized,

Clips the amplitude of each channel in each Frame yielded by self to the given threshold amplitude.

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

Create a new Signal that calls the enclosing function on each iteration.

fn fork<S>(self, ring_buffer: Bounded<S>) -> Fork<Self, S> where     Self: Sized,     S: SliceMut<Element = Self::Frame>,

Forks Self into two signals that produce the same frames.

fn bus(self) -> Bus<Self> where     Self: Sized,

Moves the Signal into a Bus from which its output may be divided into multiple other Signals in the form of Outputs.

Important traits for Take<S>

impl<S> Iterator for Take<S> where
    S: Signal,  type Item = S::Frame;

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

Converts the Signal into an Iterator that will yield the given number for Frames before returning None.

Important traits for UntilExhausted<S>

impl<S> Iterator for UntilExhausted<S> where
    S: Signal,  type Item = S::Frame;

fn until_exhausted(self) -> UntilExhausted<Self> where     Self: Sized,

Converts the Signal into an Iterator yielding frames until the signal.is_exhausted() returns true.

fn buffered<S>(self, ring_buffer: Bounded<S>) -> Buffered<Self, S> where     Self: Sized,     S: Slice<Element = Self::Frame> + SliceMut,

Buffers the signal using the given ring buffer.

fn rms<S>(self, ring_buffer: Fixed<S>) -> Rms<Self, S> where     Self: Sized,     S: Slice<Element = <Self::Frame as Frame>::Float> + SliceMut,

An adaptor that yields the RMS of the signal.

fn detect_envelope<D>(     self,     detector: Detector<Self::Frame, D> ) -> DetectEnvelope<Self, D> where     Self: Sized,     D: Detect<Self::Frame>,

An adaptor that detects and yields the envelope of the signal.

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

Borrows a Signal rather than consuming it.