Struct BufferedRead 

pub struct BufferedRead<'buf, T: Read> { /* private fields */ }

A buffered Read

The BufferedRead will read into the provided buffer to avoid small reads to the inner reader.

Implementations

impl<'buf, T: Read> BufferedRead<'buf, T>

pub fn new(inner: T, buf: &'buf mut [u8]) -> Self

Create a new buffered reader

pub fn new_with_data( inner: T, buf: &'buf mut [u8], offset: usize, available: usize, ) -> Self

Create a new buffered reader with the first available bytes readily available at offset.

This is useful if for some reason the inner reader was previously consumed by a greedy reader in a way such that the BufferedRead must inherit these excess bytes.

pub fn is_empty(&self) -> bool

Get whether there are any bytes readily available

pub fn available(&self) -> usize

Get the number of bytes that are readily availbale

pub fn bypass(&mut self) -> Result<&mut T, BypassError>

Get the inner reader if there are no currently buffered, available bytes

pub fn release(self) -> T

Release and get the inner reader

Trait Implementations

impl<T: Read> BufRead for BufferedRead<'_, T>

async fn fill_buf(&mut self) -> Result<&[u8], Self::Error>

Return 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)

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

impl<T: Read> ErrorType for BufferedRead<'_, T>

type Error = <T as ErrorType>::Error

Error type of all the IO operations on this type.

impl<T: Read> Read for BufferedRead<'_, T>

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

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

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

Read the exact number of bytes required to fill buf.

impl<T: Read + Write> Write for BufferedRead<'_, T>

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

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

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

Write an entire buffer into this writer.

async fn flush(&mut self) -> Result<(), Self::Error>

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