futures_util::io

Trait AsyncWriteExt

source
pub trait AsyncWriteExt: AsyncWrite {
    // Provided methods
    fn flush(&mut self) -> Flush<'_, Self> 
       where Self: Unpin { ... }
    fn close(&mut self) -> Close<'_, Self> 
       where Self: Unpin { ... }
    fn write<'a>(&'a mut self, buf: &'a [u8]) -> Write<'a, Self> 
       where Self: Unpin { ... }
    fn write_vectored<'a>(
        &'a mut self,
        bufs: &'a [IoSlice<'a>],
    ) -> WriteVectored<'a, Self> 
       where Self: Unpin { ... }
    fn write_all<'a>(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self> 
       where Self: Unpin { ... }
    fn write_all_vectored<'a>(
        &'a mut self,
        bufs: &'a mut [IoSlice<'a>],
    ) -> WriteAllVectored<'a, Self> 
       where Self: Unpin { ... }
    fn compat_write(self) -> Compat<Self> 
       where Self: Sized + Unpin { ... }
    fn into_sink<Item: AsRef<[u8]>>(self) -> IntoSink<Self, Item>
       where Self: Sized { ... }
}
Available on crate feature io only.
Expand description

An extension trait which adds utility methods to AsyncWrite types.

Provided Methods§

source

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

Creates a future which will entirely flush this AsyncWrite.

§Examples
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]);
source

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

Creates a future which will entirely close this AsyncWrite.

source

fn write<'a>(&'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.

source

fn write_vectored<'a>( &'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.

source

fn write_all<'a>(&'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
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]);
source

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

Attempts to write multiple buffers into this writer.

Creates a future that will write the entire contents of bufs into this AsyncWrite using vectored writes.

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

§Notes

Unlike io::Write::write_vectored, this takes a mutable reference to a slice of IoSlices, not an immutable one. That’s because we need to modify the slice to keep track of the bytes already written.

Once this futures returns, the contents of bufs are unspecified, as this depends on how many calls to write_vectored were necessary. It is best to understand this function as taking ownership of bufs and to not use bufs afterwards. The underlying buffers, to which the IoSlices point (but not the IoSlices themselves), are unchanged and can be reused.

§Examples
use futures::io::AsyncWriteExt;
use futures_util::io::Cursor;
use std::io::IoSlice;

let mut writer = Cursor::new(Vec::new());
let bufs = &mut [
    IoSlice::new(&[1]),
    IoSlice::new(&[2, 3]),
    IoSlice::new(&[4, 5, 6]),
];

writer.write_all_vectored(bufs).await?;
// Note: the contents of `bufs` is now unspecified, see the Notes section.

assert_eq!(writer.into_inner(), &[1, 2, 3, 4, 5, 6]);
source

fn compat_write(self) -> Compat<Self>
where Self: Sized + Unpin,

Available on crate feature io-compat only.

Wraps an AsyncWrite in a compatibility wrapper that allows it to be used as a futures 0.1 / tokio-io 0.1 AsyncWrite. Requires the io-compat feature to enable.

source

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

Available on crate feature sink only.

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
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]);

Object Safety§

This trait is not object safe.

Implementors§