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::empty(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 where
    B: ExactSizeBuf, 

Construct a new adapter that supports both reading and writing.

The constructed reader will be initialized so that the number of bytes available for reading are equal to what’s reported by ExactSizeBuf::frames.

Examples

use rotary::{ReadBuf, ExactSizeBuf};
use rotary::io;

let buffer = rotary::interleaved![[1, 2, 3, 4], [5, 6, 7, 8]];
assert_eq!(buffer.frames(), 4);

let buffer = io::ReadWrite::new(buffer);

assert!(buffer.has_remaining());
assert_eq!(buffer.remaining(), 4);

pub fn empty(buf: B) -> Self

Construct a new adapter that supports both reading and writing.

The constructed reader will be initialized so that there have been no frames written to it, so there will not be any frames available for reading.

Examples

use rotary::{ReadBuf, ExactSizeBuf};
use rotary::io;

let buffer = rotary::interleaved![[1, 2, 3, 4], [5, 6, 7, 8]];
assert_eq!(buffer.frames(), 4);

let buffer = io::ReadWrite::empty(buffer);

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

pub fn as_ref(&self) -> &B

Access the underlying buffer.

Examples

use rotary::Channels 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 to: rotary::Interleaved<i16> = rotary::interleaved![[1, 2, 3, 4]; 4];
let mut to = io::ReadWrite::new(to);

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

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

to.as_mut().resize_channels(2);

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

pub fn into_inner(self) -> B

Convert into the underlying buffer.

Examples

use rotary::Channels 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 read.

This can be used to rewind the internal cursor to a previously written frame if needed. Or, if the underlying buffer has changed for some reason, like if it was written to through a call to ReadWrite::as_mut.

Examples

use rotary::{Buf, Channels, ReadBuf};
use rotary::io;

fn read_from_buf(mut read: impl Buf + Channels<i16> + ReadBuf) {
    let mut out = rotary::interleaved![[0; 4]; 2];
    io::copy_remaining(read, io::Write::new(&mut out));
}

let mut buffer = io::ReadWrite::new(rotary::interleaved![[1, 2, 3, 4], [5, 6, 7, 8]]);
read_from_buf(&mut buffer);

assert!(!buffer.has_remaining());

buffer.set_read(0);

assert!(buffer.has_remaining());

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

Set the number of frames written.

This can be used to rewind the internal cursor to a previously written frame if needed. Or, if the underlying buffer has changed for some reason, like if it was read into through a call to ReadWrite::as_mut.

Examples

use rotary::{Buf, ChannelsMut, WriteBuf};
use rotary::io;

fn write_to_buf(mut write: impl Buf + ChannelsMut<i16> + WriteBuf) {
    let mut from = rotary::interleaved![[0; 4]; 2];
    io::copy_remaining(io::Read::new(&mut from), write);
}

let mut buffer = io::ReadWrite::new(rotary::interleaved![[1, 2, 3, 4], [5, 6, 7, 8]]);
write_to_buf(&mut buffer);

assert!(!buffer.has_remaining_mut());

buffer.set_written(0);

assert!(buffer.has_remaining_mut());

Trait Implementations

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

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.

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> Channels<T> for ReadWrite<B> where
    B: Channels<T>, 

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

Return a handler to the buffer associated with the channel.

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

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

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

fn copy_channels(&mut self, from: usize, to: usize) where
    T: Copy, 

Copy one channel into another.

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.