[−][src]Trait tokio::io::AsyncRead

pub trait AsyncRead: Read {
    unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool { ... }

    fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error> { ... }

    fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error>
    where
        B: BufMut,
    { ... }

    fn framed<T>(self, codec: T) -> Framed<Self, T>
    where
        Self: AsyncWrite,
        T: Decoder + Encoder,
    { ... }

    fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>)
    where
        Self: AsyncWrite,
    { ... }
}

Read bytes asynchronously.

This trait inherits from std::io::Read and indicates that an I/O object is non-blocking. All non-blocking I/O objects must return an error when bytes are unavailable instead of blocking the current thread.

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

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.

Provided methods

unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool

Prepares an uninitialized buffer to be safe to pass to read. Returns true if the supplied buffer was zeroed out.

While it would be highly unusual, implementations of io::Read are able to read data from the buffer passed as an argument. Because of this, the buffer passed to io::Read must be initialized memory. In situations where large numbers of buffers are used, constantly having to zero out buffers can be expensive.

This function does any necessary work to prepare an uninitialized buffer to be safe to pass to read. If read guarantees to never attempt to read data out of the supplied buffer, then prepare_uninitialized_buffer doesn't need to do any work.

If this function returns true, then the memory has been zeroed out. This allows implementations of AsyncRead which are composed of multiple subimplementations to efficiently implement prepare_uninitialized_buffer.

This function isn't actually unsafe to call but unsafe to implement. The implementer must ensure that either the whole buf has been zeroed or read_buf() overwrites the buffer without reading it and returns correct value.

This function is called from read_buf.

fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>

Attempt to read from the AsyncRead into buf.

On success, returns Ok(Async::Ready(num_bytes_read)).

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

fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
    B: BufMut, 

Pull some bytes from this source into the specified BufMut, returning how many bytes were read.

The buf provided will have bytes read into it and the internal cursor will be advanced if any bytes were read. Note that this method typically will not reallocate the buffer provided.

fn framed<T>(self, codec: T) -> Framed<Self, T> where
    Self: AsyncWrite,
    T: Decoder + Encoder, 

Deprecated since 0.1.7:

Use tokio_codec::Decoder::framed instead

Provides a Stream and Sink interface for reading and writing to this I/O object, using Decode and Encode to read and write the raw data.

Raw I/O objects work with byte sequences, but higher-level code usually wants to batch these into meaningful chunks, called "frames". This method layers framing on top of an I/O object, by using the Codec traits to handle encoding and decoding of messages frames. Note that the incoming and outgoing frame types may be distinct.

This function returns a single object that is both Stream and Sink; grouping this into a single object is often useful for layering things like gzip or TLS, which require both read and write access to the underlying object.

If you want to work more directly with the streams and sink, consider calling split on the Framed returned by this method, which will break them into separate objects, allowing them to interact more easily.

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite, 

Helper method for splitting this read/write object into two halves.

The two halves returned implement the Read and Write traits, respectively.

To restore this read/write object from its ReadHalf and WriteHalf use unsplit.

Loading content...

Implementations on Foreign Types

impl<'a> AsyncRead for &'a [u8][src]

impl<T> AsyncRead for Take<T> where
    T: AsyncRead, [src]

impl AsyncRead for Repeat[src]

impl<T> AsyncRead for AllowStdIo<T> where
    T: Read, [src]

impl<T> AsyncRead for Box<T> where
    T: AsyncRead + ?Sized, [src]

impl<'a, T> AsyncRead for &'a mut T where
    T: AsyncRead + ?Sized, [src]

impl<T> AsyncRead for BufReader<T> where
    T: AsyncRead, [src]

impl<T, U> AsyncRead for Chain<T, U> where
    T: AsyncRead,
    U: AsyncRead, [src]

impl<T> AsyncRead for Cursor<T> where
    T: AsRef<[u8]>, [src]

Loading content...

Implementors

impl AsyncRead for TcpStream[src]

impl<'a> AsyncRead for &'a TcpStream[src]

impl<'a, E> AsyncRead for &'a PollEvented<E> where
    E: Evented,
    &'a E: Read, [src]

impl<E> AsyncRead for PollEvented<E> where
    E: Evented + Read, [src]

impl<T> AsyncRead for ReadHalf<T> where
    T: AsyncRead, [src]

Loading content...