Struct rotary::io::ReadWrite

pub struct ReadWrite<B> { /* fields omitted */ }

Make any mutable buffer into a write adapter that implements ReadBuf and WriteBuf.

Examples

use rotary::{Buf as _, ReadBuf as _, WriteBuf as _};
use rotary::io;

let from = rotary::interleaved![[1.0f32, 2.0f32, 3.0f32, 4.0f32]; 2];
let to = rotary::interleaved![[0.0f32; 4]; 2];

// Make `to` into a read / write adapter.
let mut to = io::ReadWrite::new(to);

io::copy_remaining(io::Read::new((&from).skip(2).limit(1)), &mut to);
assert_eq!(to.remaining(), 1);

io::copy_remaining(io::Read::new((&from).limit(1)), &mut to);
assert_eq!(to.remaining(), 2);

assert_eq! {
    to.as_ref().as_slice(),
    &[3.0, 3.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0],
};

// Note: 4 channels, 2 frames each.
let mut read_out = io::Write::new(rotary::Interleaved::with_topology(4, 2));

assert_eq!(read_out.remaining_mut(), 2);
assert!(read_out.has_remaining_mut());

assert_eq!(to.remaining(), 2);
assert!(to.has_remaining());

io::copy_remaining(&mut to, &mut read_out);

assert_eq!(read_out.remaining_mut(), 0);
assert!(!read_out.has_remaining_mut());

assert_eq!(to.remaining(), 0);
assert!(!to.has_remaining());

assert_eq! {
    read_out.as_ref().as_slice(),
    &[3.0, 3.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0],
}

Implementations

impl<B> ReadWrite<B>

pub fn new(buf: B) -> Self

Construct a new read / write buffer around an audio buffer.

pub fn as_ref(&self) -> &B

Access the underlying buffer.

Examples

use rotary::Buf as _;
use rotary::io;

let buffer: rotary::Interleaved<i16> = rotary::interleaved![[1, 2, 3, 4]; 4];
let mut buffer = io::ReadWrite::new(buffer);

let from = rotary::wrap::interleaved(&[1i16, 2i16, 3i16, 4i16][..], 2);

io::translate_remaining(from, &mut buffer);

assert_eq!(buffer.as_ref().channels(), 4);

pub fn as_mut(&mut self) -> &mut B

Access the underlying buffer mutably.

Examples

use rotary::Buf as _;
use rotary::io;

let buffer: rotary::Interleaved<i16> = rotary::interleaved![[1, 2, 3, 4]; 4];
let mut buffer = io::ReadWrite::new(buffer);

let from = rotary::wrap::interleaved(&[1i16, 2i16, 3i16, 4i16][..], 2);

io::translate_remaining(from, &mut buffer);

buffer.as_mut().resize_channels(2);

assert_eq!(buffer.channels(), 2);

pub fn into_inner(self) -> B

Convert into the underlying buffer.

Examples

use rotary::Buf as _;
use rotary::io;

let buffer: rotary::Interleaved<i16> = rotary::interleaved![[1, 2, 3, 4]; 4];
let mut buffer = io::ReadWrite::new(buffer);

let from = rotary::wrap::interleaved(&[1i16, 2i16, 3i16, 4i16][..], 2);

io::translate_remaining(from, &mut buffer);

let buffer = buffer.into_inner();

assert_eq!(buffer.channels(), 4);

pub fn clear(&mut self)

Clear the state of the read / write adapter, setting both read and written to zero.

pub fn set_read(&mut self, read: usize)

Set the number of frames which have been read.

This is clamped to always be < written.

pub fn set_written(&mut self, written: usize)

Set the number of frames which have been written.

Trait Implementations

impl<B, T> Buf<T> for ReadWrite<B> where
    B: Buf<T>, 

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

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

fn channels(&self) -> usize

The number of channels in the buffer.

fn channel(&self, channel: usize) -> Channel<'_, T>

Return a handler to the buffer associated with the channel.

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

Construct a new buffer where n frames are skipped.

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

Construct a new buffer where n frames are skipped.

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

Limit the channel buffer to limit number of frames.

pub fn chunk(self, n: usize, len: usize) -> Chunk<Self>

Construct a range of frames corresponds to the chunk with len and position n.

impl<B, T> BufMut<T> for ReadWrite<B> where
    B: ExactSizeBuf + BufMut<T>, 

fn channel_mut(&mut self, channel: usize) -> ChannelMut<'_, T>

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

impl<B> ExactSizeBuf for ReadWrite<B> where
    B: ExactSizeBuf, 

fn frames(&self) -> usize

The number of frames in a buffer.

impl<B> ReadBuf for ReadWrite<B>

fn remaining(&self) -> usize

Get the number of frames remaining that can be read from the buffer.

fn advance(&mut self, n: usize)

Advance the read number of frames by n.

pub fn has_remaining(&self) -> bool

Test if there are any remaining frames to read.

impl<B> WriteBuf for ReadWrite<B> where
    B: ExactSizeBuf, 

fn remaining_mut(&self) -> usize

Remaining number of frames that can be written.

fn advance_mut(&mut self, n: usize)

Advance the number of frames that have been written.

pub fn has_remaining_mut(&self) -> bool

Test if this buffer has remaining mutable frames that can be written.