Trait futures::prelude::AsyncWriteExt

[+] Show declaration

pub trait AsyncWriteExt: AsyncWrite {
    fn flush(&mut self) -> Flush<Self>
    where
        Self: Unpin,
    { ... }
    fn close(&mut self) -> Close<Self>
    where
        Self: Unpin,
    { ... }
    fn write_all(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self>
    where
        Self: Unpin,
    { ... }
    fn compat_write(self) -> Compat<Self>
    where
        Self: Unpin,
    { ... }
}

[−] Expand description

An extension trait which adds utility methods to AsyncWrite types.

Provided methods

Important traits for Flush<'_, W>

impl<'_, W> Future for Flush<'_, W> where
    W: AsyncWrite + Unpin + ?Sized,  type Output = Result<(), Error>;

fn flush(&mut self) -> Flush<Self> where
    Self: Unpin, [+]

Creates a future which will entirely flush this AsyncWrite.

Examples

#![feature(async_await, await_macro)]
use futures::io::{AllowStdIo, AsyncWriteExt};
use std::io::{BufWriter, Cursor};

let mut output = [0u8; 5];

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

assert_eq!(output, [1, 2, 3, 4, 0]);

Important traits for Close<'_, W>

impl<'_, W> Future for Close<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<(), Error>;

fn close(&mut self) -> Close<Self> where
    Self: Unpin, [+]

Creates a future which will entirely close this AsyncWrite.

Important traits for WriteAll<'_, W>

impl<'_, W> Future for WriteAll<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<(), Error>;

fn write_all(&'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

#![feature(async_await, await_macro)]
use futures::io::AsyncWriteExt;
use std::io::Cursor;

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

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

assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);

Important traits for Compat<W>

impl<W> Write for Compat<W> where
    W: Unpin + AsyncWrite, impl<R> Read for Compat<R> where
    R: Unpin + AsyncRead, 

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

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.

Implementors

impl<W> AsyncWriteExt for W where
    W: AsyncWrite + ?Sized, [−]

Important traits for Flush<'_, W>

impl<'_, W> Future for Flush<'_, W> where
    W: AsyncWrite + Unpin + ?Sized,  type Output = Result<(), Error>;

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

Important traits for Close<'_, W>

impl<'_, W> Future for Close<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<(), Error>;

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

Important traits for WriteAll<'_, W>

impl<'_, W> Future for WriteAll<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<(), Error>;

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

Important traits for Compat<W>

impl<W> Write for Compat<W> where
    W: Unpin + AsyncWrite, impl<R> Read for Compat<R> where
    R: Unpin + AsyncRead, 

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