Trait slings::AsyncWriteExt[−][src]

pub trait AsyncWriteExt: AsyncWrite {
    fn flush(&mut self) -> Flush<'_, Self>
    where
        Self: Unpin,
    { ... }

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

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

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

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

An extension trait which adds utility methods to AsyncWrite types.

Provided methods

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

Creates a future which will entirely close this AsyncWrite.

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.

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.

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

Implementors