Struct bra::GreedyBufReader

pub struct GreedyBufReader<R> { /* fields omitted */ }

A buffered reader that greedily retains all memory read into a buffer.

Like std::io::BufReader, it fetches bytes from the source in bulk to reduce the number of actual reads. Moreover, it provides methods for reading a byte or slice of bytes at an arbitrary position, reading as many bytes as required to reach that position of the data stream, if they are not in memory already. The position indices are always relative to the position of the data source when it was passed to this construct via new or with_capacity.

Methods

impl<R> GreedyBufReader<R> where
    R: Read, 

pub fn new(src: R) -> Self

Creates a new greedy buffered reader with the given byte source.

pub fn with_capacity(src: R, capacity: usize) -> Self

Creates a new greedy buffered reader with the given byte source and the specified buffer capacity.

The buffer will be able to read approximately capacity bytes without reallocating.

pub fn into_inner(self) -> R

Retrieves the internal reader, discarding the buffer in the process.

Note that any leftover data in the internal buffer is lost.

pub fn into_buffer(self) -> Vec<u8>

Retrieves the internal buffer in its current state, discarding the reader in the process.

pub fn get(&mut self, index: usize) -> IoResult<u8>

Fetches a single byte from the buffered data source.

pub fn slice<T>(&mut self, range: T) -> IoResult<&[u8]> where
    T: Clone,
    T: RangeBounds<usize>, 

Obtains a slice of bytes.

The range's end must be bound (e.g. 5.. is not supported).

Error

Returns an I/O error if the range is out of the boundaries

Panics

Panics if the range is not end bounded.

pub fn clear(&mut self)

Clears all memory of past reads, shrinking or freeing the buffer in the process. The reader will behave as if freshly constructed, save for already prefetched data, so that no bytes are lost. The following byte being read becomes the byte at index #0.

pub fn shrink_to_fit(&mut self)

Shrinks the internal buffer to minimal capacity.

Trait Implementations

impl<R> Read for GreedyBufReader<R> where
    R: Read, 

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

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

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.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> 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 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 adaptor which will chain this stream with another.

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

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

impl<R> BufRead for GreedyBufReader<R> where
    R: Read, 

fn fill_buf(&mut self) -> IoResult<&[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, amt: 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 read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> 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.

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.