Struct BufReader

pub struct BufReader<R> { /* private fields */ }

BufReader is a struct with a buffer. BufReader implements AsyncBufRead and AsyncReadRent, and if the inner io implements AsyncWriteRent, it will delegate the implementation.

Implementations

impl<R> BufReader<R>

pub fn new(inner: R) -> Self

Create BufReader with default buffer size

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

Create BufReader with given buffer size

pub const fn get_ref(&self) -> &R

Gets a reference to the underlying reader.

It is inadvisable to directly read from the underlying reader.

pub fn get_mut(&mut self) -> &mut R

Gets a mutable reference to the underlying reader.

pub fn into_inner(self) -> R

Consumes this BufReader, returning the underlying reader.

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

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

Returns a reference to the internally buffered data.

Unlike fill_buf, this will not attempt to fill the buffer if it is empty.

Trait Implementations

impl<R: AsyncReadRent> AsyncBufRead for BufReader<R>

async fn fill_buf(&mut self) -> Result<&[u8]>

Try read data and get a reference to the internal buffer

fn consume(&mut self, amt: usize)

Mark how much data is read

impl<R: AsyncReadRent> AsyncReadRent for BufReader<R>

async fn read<T: IoBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Reads bytes from this source into the provided buffer, returning the number of bytes read.

async fn readv<T: IoVecBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Similar to read, but reads data into a slice of buffers.

impl<R: AsyncReadRent + AsyncWriteRent> AsyncWriteRent for BufReader<R>

fn write<T: IoBuf>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, T>>

Writes the contents of a buffer into this writer, returning the number of bytes written.

fn writev<T: IoVecBuf>( &mut self, buf_vec: T, ) -> impl Future<Output = BufResult<usize, T>>

This function attempts to write the entire contents of buf_vec, but the write may not fully succeed, and it might also result in an error. The bytes will be written starting at the specified offset.

fn flush(&mut self) -> impl Future<Output = Result<()>>

Flushes this output stream, ensuring that all buffered content is successfully written to its destination.

fn shutdown(&mut self) -> impl Future<Output = Result<()>>

Shuts down the output stream, ensuring that the value can be cleanly dropped.