Struct monoio::io::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 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>

type FillBufFuture<'a>
where
    Self: 'a = impl Future<Output = Result<&'a [u8], Error>>

The returned future of fill_buf

fn fill_buf(&mut self) -> Self::FillBufFuture<'_>

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>

type ReadFuture<'a, T>
where
    T: IoBufMut + 'a,
    R: 'a = impl Future<Output = (Result<usize, Error>, T)> + 'a

The future of read Result<size, buffer>

type ReadvFuture<'a, T>
where
    T: IoVecBufMut + 'a,
    R: 'a = impl Future<Output = (Result<usize, Error>, T)> + 'a

The future of readv Result<size, buffer>

fn read<T: IoBufMut>(&mut self, buf: T) -> Self::ReadFuture<'_, T>

Same as read(2)

fn readv<T: IoVecBufMut>(&mut self, buf: T) -> Self::ReadvFuture<'_, T>

Same as readv(2)

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

type WriteFuture<'a, T>
where
    T: IoBuf + 'a,
    R: 'a = <R as AsyncWriteRent>::WriteFuture<'a, T>

The future of write Result<size, buffer>

type WritevFuture<'a, T>
where
    T: IoVecBuf + 'a,
    R: 'a = <R as AsyncWriteRent>::WritevFuture<'a, T>

The future of writev Result<size, buffer>

type FlushFuture<'a>
where
    R: 'a = <R as AsyncWriteRent>::FlushFuture<'a>

The future of flush

type ShutdownFuture<'a>
where
    R: 'a = <R as AsyncWriteRent>::ShutdownFuture<'a>

The future of shutdown

fn write<T: IoBuf>(&mut self, buf: T) -> Self::WriteFuture<'_, T>

Same as write(2)

fn writev<T: IoVecBuf>(&mut self, buf_vec: T) -> Self::WritevFuture<'_, T>

Same as writev(2)

fn flush(&mut self) -> Self::FlushFuture<'_>

Flush buffered data if needed

fn shutdown(&mut self) -> Self::ShutdownFuture<'_>

Same as shutdown