Provided Methods

fn flush(self: &mut Self) -> Flush<'_, Self>
where
    Self: Unpin

Creates a future which will entirely flush this AsyncWrite.

Examples

# futures::executor::block_on(async {
use futures::io::{AllowStdIo, AsyncWriteExt};
use std::io::{BufWriter, Cursor};

let mut output = vec![0u8; 5];

{
    let writer = Cursor::new(&mut output);
    let mut buffered = AllowStdIo::new(BufWriter::new(writer));
    buffered.write_all(&[1, 2]).await?;
    buffered.write_all(&[3, 4]).await?;
    buffered.flush().await?;
}

assert_eq!(output, [1, 2, 3, 4, 0]);
# Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();

fn close(self: &mut Self) -> Close<'_, Self>
where
    Self: Unpin

Creates a future which will entirely close this AsyncWrite.

fn write<'a>(self: &'a mut Self, buf: &'a [u8]) -> Write<'a, Self>
where
    Self: Unpin

Creates a future which will write bytes from buf into the object.

The returned future will resolve to the number of bytes written once the write operation is completed.

fn write_vectored<'a>(self: &'a mut Self, bufs: &'a [IoSlice<'a>]) -> WriteVectored<'a, Self>
where
    Self: Unpin

Creates a future which will write bytes from bufs into the object using vectored IO operations.

The returned future will resolve to the number of bytes written once the write operation is completed.

fn write_all<'a>(self: &'a mut Self, buf: &'a [u8]) -> WriteAll<'a, Self>
where
    Self: Unpin

Write data into this object.

Creates a future that will write the entire contents of the buffer buf into this AsyncWrite.

The returned future will not complete until all the data has been written.

Examples

# futures::executor::block_on(async {
use futures::io::{AsyncWriteExt, Cursor};

let mut writer = Cursor::new(vec![0u8; 5]);

writer.write_all(&[1, 2, 3, 4]).await?;

assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
# Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();

fn into_sink<Item: AsRef<[u8]>>(self: Self) -> IntoSink<Self, Item>
where
    Self: Sized

Allow using an AsyncWrite as a Sink<Item: AsRef<[u8]>>.

This adapter produces a sink that will write each value passed to it into the underlying writer.

Note that this function consumes the given writer, returning a wrapped version.

Examples

# futures::executor::block_on(async {
use futures::io::AsyncWriteExt;
use futures::stream::{self, StreamExt};

let stream = stream::iter(vec![Ok([1, 2, 3]), Ok([4, 5, 6])]);

let mut writer = vec![];

stream.forward((&mut writer).into_sink()).await?;

assert_eq!(writer, vec![1, 2, 3, 4, 5, 6]);
# Ok::<(), Box<dyn std::error::Error>>(())
# })?;
# Ok::<(), Box<dyn std::error::Error>>(())