Struct vmap::io::InfiniteRing

pub struct InfiniteRing { /* fields omitted */ }

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.

pub 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.

pub 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.

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

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

pub 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.

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

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

pub 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.

pub unsafe fn initializer(&self) -> Initializer

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

Determines if this Reader can work with buffers of uninitialized memory.

pub 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.

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

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

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

Read the exact number of bytes required to fill buf.

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

Creates a "by reference" adaptor for this instance of Read.

pub fn bytes(self) -> Bytes<Self>

Transforms this Read instance to an Iterator over its bytes.

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

Creates an adaptor which will chain this stream with another.

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

Creates an adaptor 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.

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

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

pub 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.

pub 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.

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

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

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

Creates a "by reference" adaptor for this instance of Write.