Struct vmap::io::InfiniteRing

pub struct InfiniteRing { /* private fields */ }

Fixed-size lossy read/write buffer with sequential address mapping.

This uses a circular address mapping scheme. That is, for any buffer of size N, the pointer address range of 0..N maps to the same physical memory as the range N..2*N. This guarantees that the entire read or write range may be addressed as a single sequence of bytes.

Unlike the Ring, writes to this type may evict bytes from the read side of the queue. The writeable size is always equal to the overall capacity of the buffer.

Examples

use vmap::io::{InfiniteRing, SeqRead, SeqWrite};
use std::io::{BufRead, Read, Write};

let mut buf = InfiniteRing::new(4000).unwrap();
let mut i = 1;
let mut total = 0;
while total < buf.write_capacity() {
    let tmp = format!("this is test line {}\n", i);
    write!(buf, "{}", tmp);
    total += tmp.len();
    i += 1;
}

// skip over the overwritten tail
buf.consume(20 - buf.read_offset());

// read the next line
let mut line = String::new();
let len = buf.read_line(&mut line)?;

assert_eq!(len, 20);
assert_eq!(&line[line.len()-20..], "this is test line 2\n");

Implementations

impl InfiniteRing

pub fn new(hint: usize) -> Result<Self>

Constructs a new ring buffer instance.

The hint is a minimum size for the buffer. This size will be rounded up to the nearest page size for the actual capacity. The allocation will occupy double the space in the virtual memory table, but the physical memory usage will remain at the desired capacity.

Trait Implementations

impl BufRead for InfiniteRing

fn fill_buf(&mut self) -> Result<&[u8]>

Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(&mut self, len: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to read.

fn has_data_left(&mut self) -> Result<bool, Error>

🔬 This is a nightly-only experimental API. (buf_read_has_data_left)

Check if the underlying Read has any data left to be read.

fn read_until(
    &mut self,
    byte: u8,
    buf: &mut Vec<u8, Global>
) -> Result<usize, Error>

Read all bytes into buf until the delimiter byte or EOF is reached.

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until a newline (the 0xA byte) is reached, and append them to the provided buffer. You do not need to clear the buffer before appending.

fn split(self, byte: u8) -> Split<Self>

Returns an iterator over the contents of this reader split on the byte byte.

fn lines(self) -> Lines<Self>

Returns an iterator over the lines of this reader.

impl Debug for InfiniteRing

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for InfiniteRing

fn drop(&mut self)

Executes the destructor for this type.

impl Read for InfiniteRing

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill buf.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: Read, 

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it.

impl SeqRead for InfiniteRing

fn as_read_ptr(&self) -> *const u8

Get the mapped readable pointer without any offset.

fn read_offset(&self) -> usize

Get the offset from the read pointer for the current read position.

fn read_len(&self) -> usize

Get the total number of readable bytes after the read offset.

fn is_empty(&self) -> bool

Test if all read bytes have been consumed.

fn as_read_slice(&self, max: usize) -> &[u8]

Get an immutable slice covering the read region of the buffer.

fn read_from(&mut self, into: &mut [u8]) -> Result<usize>

Perform a read and consume from the read slice.

impl SeqWrite for InfiniteRing

fn as_write_ptr(&mut self) -> *mut u8

Get the mapped writable pointer without any offset.

fn write_offset(&self) -> usize

Get the offset from the write pointer for the current read position.

fn write_len(&self) -> usize

Get the total number of bytes that may be written after the current write offset.

fn write_capacity(&self) -> usize

Gets the number of bytes that the buffer has currently allocated space for.

fn feed(&mut self, len: usize)

Bump the write offset after writing into the writable slice.

fn is_full(&self) -> bool

Test if there is no room for furthur writes.

fn as_write_slice(&mut self, max: usize) -> &mut [u8]

Get a mutable slice covering the write region of the buffer.

fn write_into(&mut self, from: &[u8]) -> Result<usize>

Perform a write and feed into the write slice.

impl Write for InfiniteRing

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adapter for this instance of Write.