Trait tokio::io::AsyncRead
[−]
[src]
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 read
function will return one of the
following:
-
Ok(n)
means thatn
bytes of data was immediately read and placed into the output buffer, wheren
== 0 implies that EOF has been reached. -
Err(e) if e.kind() == ErrorKind::WouldBlock
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 likeFuture::poll
you'll receive a notification when the I/O object is readable again. -
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.
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 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 sub implementations to efficiently implement
prepare_uninitialized_buffer
.
This function isn't actually unsafe
to call but unsafe
to implement.
The implementor 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::Pending)
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,
B: BufMut,
Pull some bytes from this source into the specified Buf
, 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,
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
Provides a Stream
and Sink
interface for reading and writing to this
Io
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,
Self: AsyncWrite,
Helper method for splitting this read/write object into two halves.
The two halves returned implement the Read
and Write
traits,
respectively.
Implementations on Foreign Types
impl<T> AsyncRead for Box<T> where
T: AsyncRead + ?Sized,
[src]
T: AsyncRead + ?Sized,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<'a> AsyncRead for &'a [u8]
[src]
unsafe fn prepare_uninitialized_buffer(&self, _buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<T> AsyncRead for Cursor<T> where
T: AsRef<[u8]>,
[src]
T: AsRef<[u8]>,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<T> AsyncRead for Take<T> where
T: AsyncRead,
[src]
T: AsyncRead,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<T> AsyncRead for BufReader<T> where
T: AsyncRead,
[src]
T: AsyncRead,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl AsyncRead for Repeat
[src]
unsafe fn prepare_uninitialized_buffer(&self, &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<T, U> AsyncRead for Chain<T, U> where
T: AsyncRead,
U: AsyncRead,
[src]
T: AsyncRead,
U: AsyncRead,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<T> AsyncRead for AllowStdIo<T> where
T: Read,
[src]
T: Read,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
impl<'a, T> AsyncRead for &'a mut T where
T: AsyncRead + ?Sized,
[src]
T: AsyncRead + ?Sized,
unsafe fn prepare_uninitialized_buffer(&self, buf: &mut [u8]) -> bool
[src]
fn poll_read(&mut self, buf: &mut [u8]) -> Result<Async<usize>, Error>
[src]
fn read_buf<B>(&mut self, buf: &mut B) -> Result<Async<usize>, Error> where
B: BufMut,
[src]
B: BufMut,
fn framed<T>(self, codec: T) -> Framed<Self, T> where
Self: AsyncWrite,
T: Decoder + Encoder,
[src]
Self: AsyncWrite,
T: Decoder + Encoder,
: Use tokio_codec::Decoder::framed instead
fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
Implementors
impl<T> AsyncRead for ReadHalf<T> where
T: AsyncRead,impl AsyncRead for Stdin
impl AsyncRead for File
impl<'a, E> AsyncRead for &'a PollEvented<E> where
E: Evented,
&'a E: Read,impl<E> AsyncRead for PollEvented<E> where
E: Evented + Read,impl<'a> AsyncRead for &'a TcpStream
impl AsyncRead for TcpStream