impl<R: AsyncRead> Take<R>

fn limit(self: &Self) -> u64

Returns the remaining number of bytes that can be read before this instance will return EOF.

Note

This instance may reach EOF after reading fewer bytes than indicated by this method if the underlying AsyncRead instance reaches EOF.

Examples

# futures::executor::block_on(async {
use futures::io::{AsyncReadExt, Cursor};

let reader = Cursor::new(&b"12345678"[..]);
let mut buffer = [0; 2];

let mut take = reader.take(4);
let n = take.read(&mut buffer).await?;

assert_eq!(take.limit(), 2);
# Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();

fn set_limit(self: &mut Self, limit: u64)

Sets the number of bytes that can be read before this instance will return EOF. This is the same as constructing a new Take instance, so the amount of bytes read and the previous limit value don't matter when calling this method.

Examples

# futures::executor::block_on(async {
use futures::io::{AsyncReadExt, Cursor};

let reader = Cursor::new(&b"12345678"[..]);
let mut buffer = [0; 4];

let mut take = reader.take(4);
let n = take.read(&mut buffer).await?;

assert_eq!(n, 4);
assert_eq!(take.limit(), 0);

take.set_limit(10);
let n = take.read(&mut buffer).await?;
assert_eq!(n, 4);

# Ok::<(), Box<dyn std::error::Error>>(()) }).unwrap();

fn get_ref(self: &Self) -> &R

Acquires a reference to the underlying sink or stream that this combinator is pulling from.

fn get_mut(self: &mut Self) -> &mut R

Acquires a mutable reference to the underlying sink or stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.

fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R>

Acquires a pinned mutable reference to the underlying sink or stream that this combinator is pulling from.

Note that care must be taken to avoid tampering with the state of the sink or stream which may otherwise confuse this combinator.

fn into_inner(self: Self) -> R

Consumes this combinator, returning the underlying sink or stream.

Note that this may discard intermediate state of this combinator, so care should be taken to avoid losing resources when this is called.

impl<'__pin, R> Unpin for Take<R>

impl<R> AsyncBufReadExt for Take<R>

impl<R> AsyncReadExt for Take<R>

impl<R> Freeze for Take<R>

impl<R> RefUnwindSafe for Take<R>

impl<R> Send for Take<R>

impl<R> Sync for Take<R>

impl<R> UnsafeUnpin for Take<R>

impl<R> UnwindSafe for Take<R>

impl<R: $crate::fmt::Debug> Debug for Take<R>

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl<R: AsyncBufRead> AsyncBufRead for Take<R>

fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<&[u8]>>

fn consume(self: Pin<&mut Self>, amt: usize)

impl<R: AsyncRead> AsyncRead for Take<R>

fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<Result<usize, Error>>

impl<T> Any for Take<R>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Take<R>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Take<R>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Take<R>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Take<R>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Take<R>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Take<R>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>