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", so this trait is not object safe.

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<SendZc<T, SharedFd<Socket>>>

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

impl AsyncWriteZerocopy for &UnixStream

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

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

impl AsyncWriteZerocopy for TcpStream

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

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

impl AsyncWriteZerocopy for UnixStream

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

type VectoredBufferReadyFuture<T: IoVectoredBuf> = Zerocopy<SendVectoredZc<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>