actix_codec

# Trait AsyncRead

    pub trait AsyncRead {
        // Required method
        fn poll_read(
            self: Pin<&mut Self>,
            cx: &mut Context<'_>,
            buf: &mut ReadBuf<'_>,
        ) -> Poll<Result<(), Error>>;
    }

Expand description

Reads bytes from a source.

This trait is analogous to the `std::io::Read` trait, but integrates with the asynchronous task system. In particular, the `poll_read` method, unlike `Read::read`, will automatically queue the current task for wakeup and return if data is not yet available, rather than blocking the calling thread.

Specifically, this means that the `poll_read` function will return one of the following:

- `Poll::Ready(Ok(()))` means that data was immediately read and placed into the output buffer. The amount of data read can be determined by the increase in the length of the slice returned by `ReadBuf::filled`. If the difference is 0, either EOF has been reached, or the output buffer had zero capacity (i.e. `buf.remaining()` == 0).

- `Poll::Pending` means that no data was read into the buffer provided. The I/O object is not currently readable but may become readable in the future. Most importantly, the current future’s task is scheduled to get unparked when the object is readable. This means that like `Future::poll` you’ll receive a notification when the I/O object is readable again.

- `Poll::Ready(Err(e))` for other errors are standard I/O errors coming from the underlying object.

This trait importantly means that the `read` method only works in the context of a future’s task. The object may panic if used outside of a task.

Utilities for working with `AsyncRead` values are provided by `AsyncReadExt`.

## Required Methods§

#### fn poll_read( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

Attempts to read from the `AsyncRead` into `buf`.

On success, returns `Poll::Ready(Ok(()))` and places data in the unfilled portion of `buf`. If no data was read (`buf.filled().len()` is unchanged), it implies that EOF has been reached.

If no data is available for reading, the method returns `Poll::Pending` and arranges for the current task (via `cx.waker()`) to receive a notification when the object becomes readable or is closed.

## Implementations on Foreign Types§

§

### impl AsyncRead for &[u8]

§

#### fn poll_read( self: Pin<&mut &[u8]>, _cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<L, R> AsyncRead for Either<L, R>
where L: AsyncRead, R: AsyncRead,

§

#### fn poll_read( self: Pin<&mut Either<L, R>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<P> AsyncRead for Pin<P>
where P: DerefMut + Unpin, <P as Deref>::Target: AsyncRead,

§

#### fn poll_read( self: Pin<&mut Pin<P>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<R, F> AsyncRead for InspectReader<R, F>
where R: AsyncRead, F: FnMut(&[u8]),

§

#### fn poll_read( self: Pin<&mut InspectReader<R, F>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<S> AsyncRead for SinkWriter<S>
where S: AsyncRead,

§

#### fn poll_read( self: Pin<&mut SinkWriter<S>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<S, B, E> AsyncRead for StreamReader<S, B>
where S: Stream<Item = Result<B, E>>, B: Buf, E: Into<Error>,

§

#### fn poll_read( self: Pin<&mut StreamReader<S, B>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<T> AsyncRead for &mut T
where T: AsyncRead + Unpin + ?Sized,

§

#### fn poll_read( self: Pin<&mut &mut T>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<T> AsyncRead for Box<T>
where T: AsyncRead + Unpin + ?Sized,

§

#### fn poll_read( self: Pin<&mut Box<T>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<T> AsyncRead for Cursor<T>
where T: AsRef<[u8]> + Unpin,

§

#### fn poll_read( self: Pin<&mut Cursor<T>>, _cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

§

### impl<W, F> AsyncRead for InspectWriter<W, F>
where W: AsyncRead,

§

#### fn poll_read( self: Pin<&mut InspectWriter<W, F>>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>, ) -> Poll<Result<(), Error>>

## Implementors§

§

### impl AsyncRead for OwnedReadHalf

§

### impl AsyncRead for OwnedReadHalf

§

### impl AsyncRead for ReadHalf<'_>

§

### impl AsyncRead for ReadHalf<'_>

§

### impl AsyncRead for Receiver

§

### impl AsyncRead for TcpStream

§

### impl AsyncRead for UnixStream