Struct ensured_bufreader::EnsuredBufReader

pub struct EnsuredBufReader<R, B> where
    R: Read,
    B: AsRef<[u8]> + AsMut<[u8]>,  { /* fields omitted */ }

A BufReader that ensures ensured bytes in buffer.

EnsuredBufReader keeps ensured bytes in buffer if it can read from underlying reader. To fetch bytes into buffer, call fill_buf().

Methods

impl<R: Read> EnsuredBufReader<R, Vec<u8>>

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn new(inner: R) -> EnsuredBufReader<R, Vec<u8>>

Creates a new EnsuredBufReader with a default capacity (DEFAULT_BUFFER_SIZE) and a default ensured size (DEFAULT_ENSURED_BYTES).

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let r = EnsuredBufReader::new(f);
    Ok(())
}

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn with_capacity_and_ensured_size(
    capacity: usize,
    ensured_size: usize,
    inner: R
) -> EnsuredBufReader<R, Vec<u8>>

Creates a new EnsuredBufReader with a specified capacity and ensured_size.

capacity must be larger than or equal to ensured_size. ensured_size must be positive.

Panics

Panics if capacity is smaller than ensured_size. Panics if ensured_size is 0.

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let r = EnsuredBufReader::with_capacity_and_ensured_size(1024, 32, f);
    Ok(())
}

impl<'_, R: Read> EnsuredBufReader<R, &'_ mut [u8]>

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn from_mut_ref(buf: &mut [u8], inner: R) -> EnsuredBufReader<R, &mut [u8]>

Creates a new EnsuredBufReader with given buffer.

Buffer length must be larger than or equal to DEFAULT_ENSURED_BYTES.

Panics

Panics if buffer is smaller than DEFAULT_ENSURED_BYTES.

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let mut buf = [0u8; 1024];
    let r = EnsuredBufReader::from_mut_ref(&mut buf, f);
    Ok(())
}

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn from_mut_ref_and_ensured_size(
    buf: &mut [u8],
    ensured_size: usize,
    inner: R
) -> EnsuredBufReader<R, &mut [u8]>

Creates a new EnsuredBufReader with given buffer and a specified ensured_size.

Buffer length must be larger than or equal to ensured_size. ensured_size must be positive.

Panics

Panics if buffer is smaller than ensured_size. Panics if ensured_size is 0.

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let mut buf = [0u8; 1024];
    let r = EnsuredBufReader::from_mut_ref_and_ensured_size(&mut buf, 32, f);
    Ok(())
}

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> EnsuredBufReader<R, B>

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn from_buffer(buf: B, inner: R) -> EnsuredBufReader<R, B>

Creates a new EnsuredBufReader with given buffer.

Buffer length must be larger than or equal to DEFAULT_ENSURED_BYTES.

Panics

Panics if buffer is smaller than DEFAULT_ENSURED_BYTES.

Important traits for EnsuredBufReader<R, B>

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

pub fn from_buffer_and_ensured_size(
    buf: B,
    ensured_size: usize,
    inner: R
) -> EnsuredBufReader<R, B>

Creates a new EnsuredBufReader with given buffer and a specified ensured_size.

Buffer length must be larger than or equal to ensured_size. ensured_size must be positive.

Panics

Panics if buffer is smaller than ensured_size. Panics if ensured_size is 0.

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

Returns a reference to current buffer. This method doesn't read bytes from underlying reader.

Examples

use std::fs::File;
use std::io::{self, BufRead};
use ensured_bufreader::EnsuredBufReader;

fn main() -> io::Result<()> {
    let f = File::open("README.md")?;
    let mut r = EnsuredBufReader::new(f);

    // Read bytes from file and consume 8 bytes.
    let read_bytes = r.fill_buf()?.to_owned();
    r.consume(8);
     
    // Get buffer.
    // Current buffer should be　8 bytes shorter than `read_bytes`.
    let buf = r.buffer();
    assert_eq!(buf, &read_bytes[8..]);

    Ok(())
}

pub fn fill_buf_to_expected_size(
    &mut self,
    expected_size: usize
) -> Result<&[u8]>

Try to fill buffer and return reference to buffer. The buffer filled at least expected_size bytes if EnsuredBufReader could read from underlying reader.

Errors

Returns error that has .kind() == ErrorKind::InvalidInput if expected_size is larger than capacity.

Examples

The buffer will be filled to expected_size.

use std::fs::File;
use std::io::{self, BufRead};
use ensured_bufreader::EnsuredBufReader;

fn main() -> io::Result<()> {
    let f = File::open("README.md")?;
    let mut r = EnsuredBufReader::with_capacity_and_ensured_size(1024, 1, f);

    // Fill buffer.
    let read_bytes = r.fill_buf_to_expected_size(512)?;
    assert!(read_bytes.len() >= 512);

    Ok(())
}

If expected_size is larger than capacity, error will be returned.

use std::fs::File;
use std::io::{self, BufRead, ErrorKind};
use ensured_bufreader::EnsuredBufReader;

fn main() -> io::Result<()> {
    let f = File::open("README.md")?;
    let mut r = EnsuredBufReader::with_capacity_and_ensured_size(512, 1, f);

    let err = r.fill_buf_to_expected_size(513).unwrap_err();
    assert_eq!(err.kind(), ErrorKind::InvalidInput);

    Ok(())
}

pub fn get_capacity(&self) -> usize

Get current capacity size.

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let r = EnsuredBufReader::new(f);

    assert_eq!(r.get_capacity(), 8192);
    Ok(())
}

pub fn get_ensured_size(&self) -> usize

Get current ensured size.

Examples

use std::fs::File;
use ensured_bufreader::EnsuredBufReader;

fn main() -> std::io::Result<()> {
    let f = File::open("README.md")?;
    let r = EnsuredBufReader::new(f);

    assert_eq!(r.get_ensured_size(), 128);
    Ok(())
}

pub fn current_bytes(&self) -> usize

Returns count of bytes in buffer.

Trait Implementations

impl<R, B> Debug for EnsuredBufReader<R, B> where
    R: Read + Debug,
    B: AsRef<[u8]> + AsMut<[u8]>, 

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<R: Read, B: AsRef<[u8]> + AsMut<[u8]>> Read for EnsuredBufReader<R, B>

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.

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: Read, B: AsRef<[u8]> + AsMut<[u8]>> BufRead for EnsuredBufReader<R, B>

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