Struct better_io::BetterBufReader

pub struct BetterBufReader<R: Read> { /* private fields */ }

An implementation of BetterBufRead that wraps a generic Read.

Use this to wrap things like files and network streams, but not data that’s already in memory. This endows the Read with a buffer, unlocking a few benefits:

• better performance for repeated small reads
• doesn’t lose data when passed around by programs that optimistically read ahead

Implementations

impl<R: Read> BetterBufReader<R>

pub fn new(preloaded_data: &[u8], inner: R, capacity: usize) -> Self

Creates a BetterBufReader based on a Read.

Providing preloaded data is optional, but can be useful if instantiating based on another abstraction that held a buffer and Read.

Panics if preloaded_data is longer than capacity.

pub fn from_read_simple(inner: R) -> Self

Creates a BetterBufReader based on a Reader, supplying sensible defaults.

pub fn from_buf_reader(br: BufReader<R>, capacity: usize) -> Self

Creates a BetterBufReader based on a BufReader.

Panics if the BufReader’s buffer is longer than capacity.

pub fn into_inner(self) -> R

Returns the inner Read, dropping the BetterBufReader and its buffer.

To avoid losing data, be sure to read the last of the buffer before calling this.

Trait Implementations

impl<R: Read> BetterBufRead for BetterBufReader<R>

fn fill_or_eof(&mut self, n_bytes: usize) -> Result<()>

Fills the internal buffer with at least n_bytes if possible, or as many as possible if the end of the file is reached.

fn buffer(&self) -> &[u8]

Returns all data available in memory.

fn consume(&mut self, n_bytes: usize)

Advances by n_bytes, reducing the size of the available data to read.

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

Returns the capacity of the internal buffer, if one exists.

fn resize_capacity(&mut self, desired: usize)

Modifies capacity of the internal buffer, if one exists.