Struct BufferedWrite 

pub struct BufferedWrite<'buf, T: Write> { /* private fields */ }

A buffered Write

The BufferedWrite will write into the provided buffer to avoid small writes to the inner writer.

Implementations

impl<'buf, T: Write> BufferedWrite<'buf, T>

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

Create a new buffered writer

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

Create a new buffered writer with a pre-polulated buffer

pub fn is_empty(&self) -> bool

Get whether there are any bytes currently buffered

pub fn written(&self) -> usize

Get the number of bytes that are currently buffered but not yet written to the inner writer

pub fn clear(&mut self)

Clear the currently buffered, written bytes

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

Get the inner writer if there are no currently buffered, written bytes

pub fn bypass_with_buf(&mut self) -> Result<(&mut T, &mut [u8]), BypassError>

Get the inner writer if there are no currently buffered, written bytes, and rent the buffer

pub fn split(&mut self) -> (&mut T, &mut [u8], usize)

Split the writer to get the inner components

pub fn release(self) -> T

Release and get the inner writer

Trait Implementations

impl<T: Write> ErrorType for BufferedWrite<'_, T>

type Error = <T as ErrorType>::Error

Error type of all the IO operations on this type.

impl<T: Read + Write> Read for BufferedWrite<'_, 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: Write> Write for BufferedWrite<'_, 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 flush(&mut self) -> Result<(), Self::Error>

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

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

Write an entire buffer into this writer.