Type Definition sample::Box

type Box<T> = Box<T>;

Trait Implementations

impl<S> FromBoxedFrameSlice<[S; 1]> for Box<[S]> where
    [S; 1]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 1]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 10]> for Box<[S]> where
    [S; 10]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 10]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 11]> for Box<[S]> where
    [S; 11]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 11]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 12]> for Box<[S]> where
    [S; 12]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 12]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 13]> for Box<[S]> where
    [S; 13]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 13]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 14]> for Box<[S]> where
    [S; 14]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 14]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 15]> for Box<[S]> where
    [S; 15]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 15]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 16]> for Box<[S]> where
    [S; 16]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 16]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 17]> for Box<[S]> where
    [S; 17]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 17]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 18]> for Box<[S]> where
    [S; 18]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 18]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 19]> for Box<[S]> where
    [S; 19]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 19]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 2]> for Box<[S]> where
    [S; 2]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 2]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 20]> for Box<[S]> where
    [S; 20]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 20]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 21]> for Box<[S]> where
    [S; 21]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 21]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 22]> for Box<[S]> where
    [S; 22]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 22]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 23]> for Box<[S]> where
    [S; 23]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 23]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 24]> for Box<[S]> where
    [S; 24]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 24]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 25]> for Box<[S]> where
    [S; 25]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 25]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 26]> for Box<[S]> where
    [S; 26]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 26]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 27]> for Box<[S]> where
    [S; 27]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 27]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 28]> for Box<[S]> where
    [S; 28]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 28]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 29]> for Box<[S]> where
    [S; 29]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 29]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 3]> for Box<[S]> where
    [S; 3]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 3]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 30]> for Box<[S]> where
    [S; 30]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 30]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 31]> for Box<[S]> where
    [S; 31]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 31]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 32]> for Box<[S]> where
    [S; 32]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 32]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 4]> for Box<[S]> where
    [S; 4]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 4]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 5]> for Box<[S]> where
    [S; 5]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 5]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 6]> for Box<[S]> where
    [S; 6]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 6]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 7]> for Box<[S]> where
    [S; 7]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 7]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 8]> for Box<[S]> where
    [S; 8]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 8]]>) -> Self

impl<S> FromBoxedFrameSlice<[S; 9]> for Box<[S]> where
    [S; 9]: Frame, 

fn from_boxed_frame_slice(slice: Box<[[S; 9]]>) -> Self

impl<F> FromBoxedFrameSlice<F> for Box<[F]> where
    F: Frame, 

fn from_boxed_frame_slice(slice: Box<[F]>) -> Self

impl<S> FromBoxedSampleSlice<S> for Box<[S]> where
    S: Sample, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 1]]> where
    S: Sample,
    [S; 1]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 10]]> where
    S: Sample,
    [S; 10]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 11]]> where
    S: Sample,
    [S; 11]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 12]]> where
    S: Sample,
    [S; 12]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 13]]> where
    S: Sample,
    [S; 13]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 14]]> where
    S: Sample,
    [S; 14]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 15]]> where
    S: Sample,
    [S; 15]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 16]]> where
    S: Sample,
    [S; 16]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 17]]> where
    S: Sample,
    [S; 17]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 18]]> where
    S: Sample,
    [S; 18]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 19]]> where
    S: Sample,
    [S; 19]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 2]]> where
    S: Sample,
    [S; 2]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 20]]> where
    S: Sample,
    [S; 20]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 21]]> where
    S: Sample,
    [S; 21]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 22]]> where
    S: Sample,
    [S; 22]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 23]]> where
    S: Sample,
    [S; 23]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 24]]> where
    S: Sample,
    [S; 24]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 25]]> where
    S: Sample,
    [S; 25]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 26]]> where
    S: Sample,
    [S; 26]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 27]]> where
    S: Sample,
    [S; 27]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 28]]> where
    S: Sample,
    [S; 28]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 29]]> where
    S: Sample,
    [S; 29]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 3]]> where
    S: Sample,
    [S; 3]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 30]]> where
    S: Sample,
    [S; 30]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 31]]> where
    S: Sample,
    [S; 31]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 32]]> where
    S: Sample,
    [S; 32]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 4]]> where
    S: Sample,
    [S; 4]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 5]]> where
    S: Sample,
    [S; 5]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 6]]> where
    S: Sample,
    [S; 6]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 7]]> where
    S: Sample,
    [S; 7]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 8]]> where
    S: Sample,
    [S; 8]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S> FromBoxedSampleSlice<S> for Box<[[S; 9]]> where
    S: Sample,
    [S; 9]: Frame, 

fn from_boxed_sample_slice(slice: Box<[S]>) -> Option<Self>

impl<S: ?Sized> Signal for Box<S> where
    S: Signal, 

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.

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.

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.

impl<T> Slice for Box<[T]>

type Element = T

The type contained within the slice.

fn slice(&self) -> &[Self::Element]

Borrow the data slice.

impl<T> SliceMut for Box<[T]>

fn slice_mut(&mut self) -> &mut [Self::Element]

Mutably borrow the data slice.

impl<S> ToBoxedFrameSlice<[S; 1]> for Box<[S]> where
    S: Sample,
    [S; 1]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 1]]>>

impl<S> ToBoxedFrameSlice<[S; 10]> for Box<[S]> where
    S: Sample,
    [S; 10]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 10]]>>

impl<S> ToBoxedFrameSlice<[S; 11]> for Box<[S]> where
    S: Sample,
    [S; 11]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 11]]>>

impl<S> ToBoxedFrameSlice<[S; 12]> for Box<[S]> where
    S: Sample,
    [S; 12]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 12]]>>

impl<S> ToBoxedFrameSlice<[S; 13]> for Box<[S]> where
    S: Sample,
    [S; 13]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 13]]>>

impl<S> ToBoxedFrameSlice<[S; 14]> for Box<[S]> where
    S: Sample,
    [S; 14]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 14]]>>

impl<S> ToBoxedFrameSlice<[S; 15]> for Box<[S]> where
    S: Sample,
    [S; 15]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 15]]>>

impl<S> ToBoxedFrameSlice<[S; 16]> for Box<[S]> where
    S: Sample,
    [S; 16]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 16]]>>

impl<S> ToBoxedFrameSlice<[S; 17]> for Box<[S]> where
    S: Sample,
    [S; 17]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 17]]>>

impl<S> ToBoxedFrameSlice<[S; 18]> for Box<[S]> where
    S: Sample,
    [S; 18]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 18]]>>

impl<S> ToBoxedFrameSlice<[S; 19]> for Box<[S]> where
    S: Sample,
    [S; 19]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 19]]>>

impl<S> ToBoxedFrameSlice<[S; 2]> for Box<[S]> where
    S: Sample,
    [S; 2]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 2]]>>

impl<S> ToBoxedFrameSlice<[S; 20]> for Box<[S]> where
    S: Sample,
    [S; 20]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 20]]>>

impl<S> ToBoxedFrameSlice<[S; 21]> for Box<[S]> where
    S: Sample,
    [S; 21]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 21]]>>

impl<S> ToBoxedFrameSlice<[S; 22]> for Box<[S]> where
    S: Sample,
    [S; 22]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 22]]>>

impl<S> ToBoxedFrameSlice<[S; 23]> for Box<[S]> where
    S: Sample,
    [S; 23]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 23]]>>

impl<S> ToBoxedFrameSlice<[S; 24]> for Box<[S]> where
    S: Sample,
    [S; 24]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 24]]>>

impl<S> ToBoxedFrameSlice<[S; 25]> for Box<[S]> where
    S: Sample,
    [S; 25]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 25]]>>

impl<S> ToBoxedFrameSlice<[S; 26]> for Box<[S]> where
    S: Sample,
    [S; 26]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 26]]>>

impl<S> ToBoxedFrameSlice<[S; 27]> for Box<[S]> where
    S: Sample,
    [S; 27]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 27]]>>

impl<S> ToBoxedFrameSlice<[S; 28]> for Box<[S]> where
    S: Sample,
    [S; 28]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 28]]>>

impl<S> ToBoxedFrameSlice<[S; 29]> for Box<[S]> where
    S: Sample,
    [S; 29]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 29]]>>

impl<S> ToBoxedFrameSlice<[S; 3]> for Box<[S]> where
    S: Sample,
    [S; 3]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 3]]>>

impl<S> ToBoxedFrameSlice<[S; 30]> for Box<[S]> where
    S: Sample,
    [S; 30]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 30]]>>

impl<S> ToBoxedFrameSlice<[S; 31]> for Box<[S]> where
    S: Sample,
    [S; 31]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 31]]>>

impl<S> ToBoxedFrameSlice<[S; 32]> for Box<[S]> where
    S: Sample,
    [S; 32]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 32]]>>

impl<S> ToBoxedFrameSlice<[S; 4]> for Box<[S]> where
    S: Sample,
    [S; 4]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 4]]>>

impl<S> ToBoxedFrameSlice<[S; 5]> for Box<[S]> where
    S: Sample,
    [S; 5]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 5]]>>

impl<S> ToBoxedFrameSlice<[S; 6]> for Box<[S]> where
    S: Sample,
    [S; 6]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 6]]>>

impl<S> ToBoxedFrameSlice<[S; 7]> for Box<[S]> where
    S: Sample,
    [S; 7]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 7]]>>

impl<S> ToBoxedFrameSlice<[S; 8]> for Box<[S]> where
    S: Sample,
    [S; 8]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 8]]>>

impl<S> ToBoxedFrameSlice<[S; 9]> for Box<[S]> where
    S: Sample,
    [S; 9]: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[[S; 9]]>>

impl<F> ToBoxedFrameSlice<F> for Box<[F]> where
    F: Frame, 

fn to_boxed_frame_slice(self) -> Option<Box<[F]>>

impl<S> ToBoxedSampleSlice<S> for Box<[S]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 1]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 10]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 11]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 12]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 13]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 14]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 15]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 16]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 17]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 18]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 19]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 2]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 20]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 21]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 22]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 23]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 24]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 25]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 26]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 27]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 28]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 29]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 3]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 30]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 31]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 32]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 4]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 5]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 6]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 7]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 8]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>

impl<S> ToBoxedSampleSlice<S> for Box<[[S; 9]]> where
    S: Sample, 

fn to_boxed_sample_slice(self) -> Box<[S]>