[−][src]Trait futures::io::AsyncReadExt
An extension trait which adds utility methods to AsyncRead
types.
Provided methods
ⓘImportant traits for CopyInto<'_, R, W>default fn copy_into<W>(
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
Creates a future which copies all the bytes from one object to another.
The returned future will copy all the bytes read from this AsyncRead
into the
writer
specified. This future will only complete once the reader
has hit
EOF and all bytes have been written to and flushed from the writer
provided.
On success the number of bytes is returned.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::Cursor; let mut reader = Cursor::new([1, 2, 3, 4]); let mut writer = Cursor::new([0u8; 5]); let bytes = await!(reader.copy_into(&mut writer))?; assert_eq!(bytes, 4); assert_eq!(writer.into_inner(), [1, 2, 3, 4, 0]);
ⓘImportant traits for Read<'_, R>default fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,
Self: Unpin,
Tries to read some bytes directly into the given buf
in asynchronous
manner, returning a future type.
The returned future will resolve to the number of bytes read once the read operation is completed.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::Cursor; let mut reader = Cursor::new([1, 2, 3, 4]); let mut output = [0u8; 5]; let bytes = await!(reader.read(&mut output[..]))?; // This is only guaranteed to be 4 because `&[u8]` is a synchronous // reader. In a real system you could get anywhere from 1 to // `output.len()` bytes in a single read. assert_eq!(bytes, 4); assert_eq!(output, [1, 2, 3, 4, 0]);
ⓘImportant traits for ReadExact<'_, R>default fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,
Self: Unpin,
Creates a future which will read exactly enough bytes to fill buf
,
returning an error if end of file (EOF) is hit sooner.
The returned future will resolve once the read operation is completed.
In the case of an error the buffer and the object will be discarded, with the error yielded.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::Cursor; let mut reader = Cursor::new([1, 2, 3, 4]); let mut output = [0u8; 4]; await!(reader.read_exact(&mut output))?; assert_eq!(output, [1, 2, 3, 4]);
EOF is hit before buf
is filled
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::{self, Cursor}; let mut reader = Cursor::new([1, 2, 3, 4]); let mut output = [0u8; 5]; let result = await!(reader.read_exact(&mut output)); assert_eq!(result.unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
ⓘImportant traits for ReadToEnd<'_, A>default fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
Creates a future which will read all the bytes from this AsyncRead
.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::Cursor; let mut reader = Cursor::new([1, 2, 3, 4]); let mut output = Vec::with_capacity(4); await!(reader.read_to_end(&mut output))?; assert_eq!(output, vec![1, 2, 3, 4]);
default 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 AsyncRead
and AsyncWrite
traits, respectively.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::io::AsyncReadExt; use std::io::Cursor; // Note that for `Cursor` the read and write halves share a single // seek position. This may or may not be true for other types that // implement both `AsyncRead` and `AsyncWrite`. let mut reader = Cursor::new([1, 2, 3, 4]); let mut buffer = Cursor::new([0, 0, 0, 0, 5, 6, 7, 8]); let mut writer = Cursor::new([0u8; 5]); { let (mut buffer_reader, mut buffer_writer) = (&mut buffer).split(); await!(reader.copy_into(&mut buffer_writer))?; await!(buffer_reader.copy_into(&mut writer))?; } assert_eq!(buffer.into_inner(), [1, 2, 3, 4, 5, 6, 7, 8]); assert_eq!(writer.into_inner(), [5, 6, 7, 8, 0]);
ⓘImportant traits for Compat<R>default fn compat(self) -> Compat<Self> where
Self: Unpin,
Self: Unpin,
Wraps an AsyncRead
in a compatibility wrapper that allows it to be
used as a futures 0.1 / tokio-io 0.1 AsyncRead
. If the wrapped type
implements AsyncWrite
as well, the result will also implement the
futures 0.1 / tokio 0.1 AsyncWrite
trait.
Requires the io-compat
feature to enable.
Implementors
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,
[src]
R: AsyncRead + ?Sized,
ⓘImportant traits for CopyInto<'_, R, W>default fn copy_into<W>(
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
[src]
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
ⓘImportant traits for Read<'_, R>default fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
ⓘImportant traits for ReadExact<'_, R>default fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
ⓘImportant traits for ReadToEnd<'_, A>default fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
default fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
ⓘImportant traits for Compat<R>default fn compat(self) -> Compat<Self> where
Self: Unpin,
[src]
Self: Unpin,