Struct BufferedIo

pub struct BufferedIo<'a, St, W, const READ_BUF_LIMIT: usize> {
    pub io: &'a mut St,
    pub read_buf: ReadBuf<READ_BUF_LIMIT>,
    pub write_buf: W,
}

Io type with internal buffering.

Fields

io: &'a mut St

mut reference of Io type that impl AsyncIo trait.

read_buf: ReadBuf<READ_BUF_LIMIT>

read buffer with const generic usize as capacity limit.

write_buf: W

generic type impl BufWrite trait as write buffer.

Implementations

impl<'a, St, W, const READ_BUF_LIMIT: usize> BufferedIo<'a, St, W, READ_BUF_LIMIT>

where St: AsyncIo, W: BufWrite,

pub fn new(io: &'a mut St, write_buf: W) -> Self

construct a new buffered io with given Io and buf writer.

pub fn try_read(&mut self) -> Result<()>

read until io blocked or read buffer is full and advance the length of it(read buffer).

pub fn try_write(&mut self) -> Result<()>

write until write buffer is emptied or io blocked.

pub async fn read(&mut self) -> Result<()>

check for io read readiness in async and do Self::try_read.

pub async fn drain_write(&mut self) -> Result<()>

drain write buffer and flush the io.

pub fn shutdown(&mut self) -> impl Future<Output = Result<()>> + '_

shutdown Io gracefully.