Trait AsyncWriteZerocopy 

pub trait AsyncWriteZerocopy {
    type BufferReadyFuture<T: IoBuf>: Future<Output = T>;
    type VectoredBufferReadyFuture<T: IoVectoredBuf>: Future<Output = T>;

    // Required methods
    fn write_zerocopy<T>(
        &mut self,
        buf: T,
    ) -> impl Future<Output = BufResult<usize, Self::BufferReadyFuture<T>>>
       where T: IoBuf;
    fn write_zerocopy_vectored<T>(
        &mut self,
        buf: T,
    ) -> impl Future<Output = BufResult<usize, Self::VectoredBufferReadyFuture<T>>>
       where T: IoVectoredBuf;
}

Available on crate feature io only.

AsyncZeroCopyWrite

Async zerocopy write with ownership of a buffer.

Required Associated Types

type BufferReadyFuture<T: IoBuf>: Future<Output = T>

The future that will be resolved when the buffer is safe to be reused.

type VectoredBufferReadyFuture<T: IoVectoredBuf>: Future<Output = T>

The future that will be resolved when the vectored buffer is safe to be reused.

Required Methods

fn write_zerocopy<T>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, Self::BufferReadyFuture<T>>>

where T: IoBuf,

Write some bytes from buffer into this source using the underlying zero-copy mechanism. It returns a result of the underlying write operation and a future that will be resolved when the buffer is safe to be reused.

fn write_zerocopy_vectored<T>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, Self::VectoredBufferReadyFuture<T>>>

where T: IoVectoredBuf,

Like write_zerocopy, except that it writes from a buffer implements IoVectoredBuf into the source.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A> AsyncWriteZerocopy for &mut A

where A: AsyncWriteZerocopy + ?Sized,

type BufferReadyFuture<T: IoBuf> = <A as AsyncWriteZerocopy>::BufferReadyFuture<T>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = <A as AsyncWriteZerocopy>::VectoredBufferReadyFuture<T>

fn write_zerocopy<T>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, <&mut A as AsyncWriteZerocopy>::BufferReadyFuture<T>>>

where T: IoBuf,

fn write_zerocopy_vectored<T>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, <&mut A as AsyncWriteZerocopy>::VectoredBufferReadyFuture<T>>>

where T: IoVectoredBuf,

Implementors

impl AsyncWriteZerocopy for &TcpStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

impl AsyncWriteZerocopy for &UnixStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

impl AsyncWriteZerocopy for TcpStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

impl AsyncWriteZerocopy for UnixStream

type BufferReadyFuture<T: IoBuf> = Zerocopy<Send<T, SharedFd<Socket>>>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectored<T, SharedFd<Socket>>>

impl<A> AsyncWriteZerocopy for Vec<u8, A>

where A: Allocator,

type BufferReadyFuture<T: IoBuf> = Ready<T>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Ready<T>

impl<W, A> AsyncWriteZerocopy for Box<W, A>

where W: AsyncWriteZerocopy + ?Sized, A: Allocator,

type BufferReadyFuture<T: IoBuf> = <W as AsyncWriteZerocopy>::BufferReadyFuture<T>

type VectoredBufferReadyFuture<T: IoVectoredBuf> = <W as AsyncWriteZerocopy>::VectoredBufferReadyFuture<T>