Struct audio::wrap::Sequential

pub struct Sequential<T> { /* private fields */ }

A wrapper for a sequential audio buffer.

See wrap::sequential.

Implementations

impl<T> Sequential<T>

where T: Slice,

pub fn into_inner(self) -> T

Convert back into the wrapped value.

Examples

let buf = audio::wrap::sequential(&[1, 2, 3, 4], 2);
assert_eq!(buf.into_inner(), &[1, 2, 3, 4]);

pub fn iter(&self) -> IterChannels<'_, T::Item>

Construct an iterator over all sequential channels.

Examples

let buf = audio::wrap::sequential(&[1, 2, 3, 4], 2);
let mut it = buf.iter();

assert_eq!(it.next().unwrap(), [1, 2]);
assert_eq!(it.next().unwrap(), [3, 4]);

impl<T> Sequential<T>

where T: SliceMut,

pub fn iter_mut(&mut self) -> IterChannelsMut<'_, T::Item>

Construct an iterator over all sequential channels.

Trait Implementations

impl<T> Buf for Sequential<T>

where T: Slice,

type Sample = <T as Slice>::Item

The type of a single sample.

type Channel<'this> = LinearChannel<'this, <Sequential<T> as Buf>::Sample> where Self: 'this

The type of the channel container.

type IterChannels<'this> = IterChannels<'this, <Sequential<T> as Buf>::Sample> where Self: 'this

An iterator over available channels.

fn frames_hint(&self) -> Option<usize>

A typical number of frames for each channel in the buffer, if known.

fn channels(&self) -> usize

The number of channels in the buffer.

fn get_channel(&self, channel: usize) -> Option<Self::Channel<'_>>

Return a handler to the buffer associated with the channel.

fn iter_channels(&self) -> Self::IterChannels<'_>

Construct an iterator over all the channels in the audio buffer.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Construct a wrapper around this buffer that skips the first n frames.

fn tail(self, n: usize) -> Tail<Self>

where Self: Sized,

Construct a wrapper around this buffer that skips to the last n frames.

fn limit(self, limit: usize) -> Limit<Self>

where Self: Sized,

Construct a wrapper around this buffer which stops after limit frames.

impl<T> BufMut for Sequential<T>

where T: SliceMut,

type ChannelMut<'a> = LinearChannelMut<'a, <Sequential<T> as Buf>::Sample> where Self: 'a

The type of the mutable channel container.

type IterChannelsMut<'a> = IterChannelsMut<'a, <Sequential<T> as Buf>::Sample> where Self: 'a

A mutable iterator over available channels.

fn get_channel_mut(&mut self, channel: usize) -> Option<Self::ChannelMut<'_>>

Return a mutable handler to the buffer associated with the channel.

fn copy_channel(&mut self, from: usize, to: usize)

Copy one channel into another.

fn iter_channels_mut(&mut self) -> Self::IterChannelsMut<'_>

Construct a mutable iterator over available channels.

impl<T> ExactSizeBuf for Sequential<T>

where T: Slice,

fn frames(&self) -> usize

The number of frames in a buffer.

impl<T> UniformBuf for Sequential<T>

where T: Slice,

type Frame<'this> = SequentialFrame<'this, <T as Slice>::Item> where Self: 'this

The type the channel assumes when coerced into a reference.

type IterFrames<'this> = SequentialFramesIter<'this, <T as Slice>::Item> where Self: 'this

A borrowing iterator over the channel.

fn get_frame(&self, frame: usize) -> Option<Self::Frame<'_>>

Get a single frame at the given offset.

fn iter_frames(&self) -> Self::IterFrames<'_>

Construct an iterator over all the frames in the audio buffer.