Trait AsyncWriteWith

pub trait AsyncWriteWith<'a> {
    type WriteFuture: CompletionFuture<Output = Result<usize>>;
    type WriteVectoredFuture: CompletionFuture<Output = Result<usize>>;
    type FlushFuture: CompletionFuture<Output = Result<()>>;

    // Required methods
    fn write(&'a mut self, buf: &'a [u8]) -> Self::WriteFuture;
    fn write_vectored(
        &'a mut self,
        bufs: &'a [IoSlice<'a>],
    ) -> Self::WriteVectoredFuture;
    fn flush(&'a mut self) -> Self::FlushFuture;

    // Provided method
    fn is_write_vectored(&self) -> bool { ... }
}

Write bytes to a source asynchronously with a specific lifetime.

Required Associated Types

type WriteFuture: CompletionFuture<Output = Result<usize>>

The future that writes to the source, and outputs the number of bytes written.

type WriteVectoredFuture: CompletionFuture<Output = Result<usize>>

The future that writes a vector of buffers to the source, and outputs the number of bytes written. If your writer does not have efficient vectored writes, set this to DefaultWriteVectored<'a, Self>.

type FlushFuture: CompletionFuture<Output = Result<()>>

The future that flushes the output stream.

Required Methods

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

Write a buffer to the writer, returning how many bytes were written.

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

Like write, except that it writes from a slice of buffers.

Data is copied from each buffer in order, with the final buffer read from possibly being only partially consumed. This method must behave as a call to write with the buffers concatenated would.

If your writer does not have efficient vectored writes, call DefaultWriteVectored::new(self, bufs).

fn flush(&'a mut self) -> Self::FlushFuture

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

Provided Methods

fn is_write_vectored(&self) -> bool

Determines if this AsyncWriter has an efficient write_vectored implementation.

The default implementation returns false.

Implementations on Foreign Types

impl<'a> AsyncWriteWith<'a> for &Sink

type WriteFuture = Ready<Result<usize, Error>>

type WriteVectoredFuture = Ready<Result<usize, Error>>

type FlushFuture = Ready<Result<(), Error>>

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

impl<'a> AsyncWriteWith<'a> for Vec<u8>

type WriteFuture = WriteVec<'a>

type WriteVectoredFuture = WriteVectoredVec<'a>

type FlushFuture = Ready<Result<(), Error>>

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

impl<'a> AsyncWriteWith<'a> for Sink

type WriteFuture = Ready<Result<usize, Error>>

type WriteVectoredFuture = Ready<Result<usize, Error>>

type FlushFuture = Ready<Result<(), Error>>

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

impl<'a, 's> AsyncWriteWith<'a> for &'s mut [u8]

type WriteFuture = WriteSlice<'a, 's>

type WriteVectoredFuture = WriteVectoredSlice<'a, 's>

type FlushFuture = Ready<Result<(), Error>>

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

impl<'a, W: AsyncWriteWith<'a> + ?Sized> AsyncWriteWith<'a> for &mut W

type WriteFuture = <W as AsyncWriteWith<'a>>::WriteFuture

type WriteVectoredFuture = <W as AsyncWriteWith<'a>>::WriteVectoredFuture

type FlushFuture = <W as AsyncWriteWith<'a>>::FlushFuture

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

impl<'a, W: AsyncWriteWith<'a> + ?Sized> AsyncWriteWith<'a> for Box<W>

type WriteFuture = <W as AsyncWriteWith<'a>>::WriteFuture

type WriteVectoredFuture = <W as AsyncWriteWith<'a>>::WriteVectoredFuture

type FlushFuture = <W as AsyncWriteWith<'a>>::FlushFuture

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

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

fn is_write_vectored(&self) -> bool

fn flush(&'a mut self) -> Self::FlushFuture

Implementors