Struct BufWriter 

pub struct BufWriter<W> { /* private fields */ }

Available on crate feature io only.

Wraps a writer and buffers its output.

It can be excessively inefficient to work directly with something that implements AsyncWrite. A BufWriter<W> keeps an in-memory buffer of data and writes it to an underlying writer in large, infrequent batches. BufWriter<W> can improve the speed of programs that make small and repeated write calls to the same file or network socket. It does not help when writing very large amounts at once, or writing just one or a few times. It also provides no advantage when writing to a destination that is in memory, like a Vec<u8>.

If the underlying writer also implements AsyncRead or AsyncBufRead, BufWriter<W> forwards read operations directly to the inner reader without flushing the write buffer.

Dropping BufWriter<W> also discards any bytes left in the buffer, so it is critical to call flush before BufWriter<W> is dropped. Calling flush ensures that the buffer is empty and thus no data is lost.

Implementations

impl<W> BufWriter<W>

pub fn new(writer: W) -> BufWriter<W>

Creates a new BufWriter with a default buffer capacity. The default is currently 8 KiB, but may change in the future.

pub fn with_capacity(cap: usize, writer: W) -> BufWriter<W>

Creates a new BufWriter with the specified buffer capacity.

Trait Implementations

impl<W> AsyncBufRead for BufWriter<W>

where W: AsyncBufRead + AsyncWrite,

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

Try fill the internal buffer with data

fn consume(&mut self, amount: usize)

Mark how much data is read

impl<W> AsyncRead for BufWriter<W>

where W: AsyncRead + AsyncWrite,

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

where B: IoBufMut,

Read some bytes from this source into the IoBufMut buffer and return a BufResult, consisting of the buffer and a usize indicating how many bytes were read.

async fn read_vectored<V>(&mut self, buf: V) -> BufResult<usize, V>

where V: IoVectoredBufMut,

Like read, except that it reads into a type implements IoVectoredBufMut.

impl<W> AsyncWrite for BufWriter<W>

where W: AsyncWrite,

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

where T: IoBuf,

Write some bytes from the buffer into this source and return a BufResult, consisting of the buffer and a usize indicating how many bytes were written.

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

where T: IoVectoredBuf,

Like write, except that it write bytes from a buffer implements IoVectoredBuf into the source.

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

Attempts to flush the object, ensuring that any buffered data reach their destination.

async fn shutdown(&mut self) -> Result<(), Error>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

impl<W> Debug for BufWriter<W>

where W: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<W> IntoInner for BufWriter<W>

type Inner = W

The inner type.

fn into_inner(self) -> <BufWriter<W> as IntoInner>::Inner

Get the inner buffer.