[−][src]Trait geng_core::prelude::futures::io::AsyncWriteExt

pub trait AsyncWriteExt: AsyncWrite {
    fn flush(&mut self) -> Flush<Self>ⓘ
Important traits for Flush<'_, W>
impl<'_, W> Future for Flush<'_, W> where
    W: AsyncWrite + Unpin + ?Sized,     type Output = Result<(), Error>;

    where
        Self: Unpin,
    { ... }

    fn close(&mut self) -> Close<Self>ⓘ
Important traits for Close<'_, W>
impl<'_, W> Future for Close<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,     type Output = Result<(), Error>;

    where
        Self: Unpin,
    { ... }

    fn write(&'a mut self, buf: &'a [u8]) -> Write<'a, Self>ⓘ
Important traits for Write<'_, W>
impl<'_, W> Future for Write<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,     type Output = Result<usize, Error>;

    where
        Self: Unpin,
    { ... }

    fn write_vectored(
        &'a mut self, 
        bufs: &'a [IoSlice<'a>]
    ) -> WriteVectored<'a, Self>ⓘ
Important traits for WriteVectored<'_, W>
impl<'_, W> Future for WriteVectored<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,     type Output = Result<usize, Error>;

    where
        Self: Unpin,
    { ... }

    fn write_all(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self>ⓘ
Important traits for WriteAll<'_, W>
impl<'_, W> Future for WriteAll<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,     type Output = Result<(), Error>;

    where
        Self: Unpin,
    { ... }

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

An extension trait which adds utility methods to AsyncWrite types.

Provided methods

fn flush(&mut self) -> Flush<Self>ⓘ

Important traits for Flush<'_, W>

impl<'_, W> Future for Flush<'_, W> where
    W: AsyncWrite + Unpin + ?Sized,  type Output = Result<(), Error>;
 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 = [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]);

fn close(&mut self) -> Close<Self>ⓘ

Important traits for Close<'_, W>

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

Creates a future which will entirely close this AsyncWrite.

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

Important traits for Write<'_, W>

impl<'_, W> Future for Write<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<usize, Error>;
 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 mut self,
    bufs: &'a [IoSlice<'a>]
) -> WriteVectored<'a, Self>ⓘ

Important traits for WriteVectored<'_, W>

impl<'_, W> Future for WriteVectored<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<usize, Error>;
 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 mut self, buf: &'a [u8]) -> WriteAll<'a, Self>ⓘ

Important traits for WriteAll<'_, W>

impl<'_, W> Future for WriteAll<'_, W> where
    W: Unpin + AsyncWrite + ?Sized,  type Output = Result<(), Error>;
 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;
use std::io::Cursor;

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

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

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

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

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]);
Loading content...

Implementors

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

Loading content...