Trait Read 

pub trait Read: ErrorType {
    // Required method
    async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>;

    // Provided method
    async fn read_exact(
        &mut self,
        buf: &mut [u8],
    ) -> Result<(), ReadExactError<Self::Error>> { ... }
}

Async reader.

This trait is the embedded-io-async equivalent of std::io::Read.

Required Methods

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

If no bytes are currently available to read:

• The method waits until at least one byte becomes available;
• Once at least one (or more) bytes become available, a non-zero amount of those is copied to the beginning of buf, and the amount is returned, without waiting any further for more bytes to become available.

If bytes are available to read:

• A non-zero amount of bytes is read to the beginning of buf, and the amount is returned immediately, without waiting for more bytes to become available;

Note that once some bytes are available to read, it is not guaranteed that all available bytes are returned. It is possible for the implementation to read an amount of bytes less than buf.len() while there are more bytes immediately available.

This waiting behavior is important for the cases where Read represents the “read” leg of a pipe-like protocol (a socket, a pipe, a serial line etc.). The semantics is that the caller - by passing a non-empty buffer - does expect some data (one or more bytes) - but not necessarily buf.len() or more bytes - to become available, before the peer represented by Read would stop sending bytes due to application-specific reasons (as in the peer waiting for a response to the data it had sent so far).

If the reader is at end-of-file (EOF), Ok(0) is returned. There is no guarantee that a reader at EOF will always be so in the future, for example a reader can stop being at EOF if another process appends more bytes to the underlying file.

If buf.len() == 0, read returns without waiting, with either Ok(0) or an error. The Ok(0) doesn’t indicate EOF, unlike when called with a non-empty buffer.

Implementations are encouraged to make this function side-effect-free on cancel (AKA “cancel-safe”), i.e. guarantee that if you cancel (drop) a read() future that hasn’t completed yet, the stream’s state hasn’t changed (no bytes have been read).

This is not a requirement to allow implementations that read into the user’s buffer straight from the hardware with e.g. DMA.

Implementations should document whether they’re actually side-effect-free on cancel or not.

Provided Methods

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

This function calls read() in a loop until exactly buf.len() bytes have been read, waiting if needed.

This function is not side-effect-free on cancel (AKA “cancel-safe”), i.e. if you cancel (drop) a returned future that hasn’t completed yet, some bytes might have already been read, which will get lost.

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 Read for &[u8]

Read is implemented for &[u8] by copying from the slice.

Note that reading updates the slice to point to the yet unread part. The slice will be empty when EOF is reached.

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

impl Read for VecDeque<u8>

Available on crate features std or alloc only.

Read is implemented for VecDeque<u8> by consuming bytes from the front of the VecDeque.

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Fill buf with the contents of the “front” slice as returned by as_slices. If the contained byte slices of the VecDeque are discontiguous, multiple calls to read will be needed to read the entire content.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

impl<T: ?Sized + Read> Read for &mut T

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

impl<T: ?Sized + Read> Read for Box<T>

Available on crate features std or alloc only.

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Implementors