Struct futures_lite::io::Take

source ·
pub struct Take<R> { /* private fields */ }
Expand description

Reader for the AsyncReadExt::take() method.

Implementations§

source§

impl<R> Take<R>

source

pub fn limit(&self) -> u64

Returns the number of bytes before this adapter will return EOF.

Note that EOF may be reached sooner if the underlying reader is shorter than the limit.

§Examples
use futures_lite::io::{AsyncReadExt, Cursor};

let reader = Cursor::new("hello");

let reader = reader.take(3);
assert_eq!(reader.limit(), 3);
source

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

Puts a limit on the number of bytes.

Changing the limit is equivalent to creating a new adapter with AsyncReadExt::take().

§Examples
use futures_lite::io::{AsyncReadExt, Cursor};

let reader = Cursor::new("hello");

let mut reader = reader.take(10);
assert_eq!(reader.limit(), 10);

reader.set_limit(3);
assert_eq!(reader.limit(), 3);
source

pub fn get_ref(&self) -> &R

Gets a reference to the underlying reader.

§Examples
use futures_lite::io::{AsyncReadExt, Cursor};

let reader = Cursor::new("hello");

let reader = reader.take(3);
let r = reader.get_ref();
source

pub fn get_mut(&mut self) -> &mut R

Gets a mutable reference to the underlying reader.

§Examples
use futures_lite::io::{AsyncReadExt, Cursor};

let reader = Cursor::new("hello");

let mut reader = reader.take(3);
let r = reader.get_mut();
source

pub fn into_inner(self) -> R

Unwraps the adapter, returning the underlying reader.

§Examples
use futures_lite::io::{AsyncReadExt, Cursor};

let reader = Cursor::new("hello");

let reader = reader.take(3);
let reader = reader.into_inner();

Trait Implementations§

source§

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

source§

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

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
source§

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

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read. Read more
source§

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

source§

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

Attempt to read from the AsyncRead into buf. Read more
source§

fn poll_read_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &mut [IoSliceMut<'_>], ) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations. Read more
source§

impl<R: Debug> Debug for Take<R>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'__pin, R> Unpin for Take<R>
where __Origin<'__pin, R>: Unpin,

Auto Trait Implementations§

§

impl<R> Freeze for Take<R>
where R: Freeze,

§

impl<R> RefUnwindSafe for Take<R>
where R: RefUnwindSafe,

§

impl<R> Send for Take<R>
where R: Send,

§

impl<R> Sync for Take<R>
where R: Sync,

§

impl<R> UnwindSafe for Take<R>
where R: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<R> AsyncBufReadExt for R
where R: AsyncBufRead + ?Sized,

source§

fn fill_buf(&mut self) -> FillBuf<'_, Self>
where Self: Unpin,

Returns the contents of the internal buffer, filling it with more data if empty. Read more
source§

fn consume(&mut self, amt: usize)
where Self: Unpin,

Consumes amt buffered bytes. Read more
source§

fn read_until<'a>( &'a mut self, byte: u8, buf: &'a mut Vec<u8>, ) -> ReadUntilFuture<'_, Self>
where Self: Unpin,

Reads all bytes and appends them into buf until the delimiter byte or EOF is found. Read more
source§

fn read_line<'a>(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'_, Self>
where Self: Unpin,

Reads all bytes and appends them into buf until a newline (the 0xA byte) or EOF is found. Read more
source§

fn lines(self) -> Lines<Self>
where Self: Unpin + Sized,

Returns a stream over the lines of this byte stream. Read more
source§

fn split(self, byte: u8) -> Split<Self>
where Self: Sized,

Returns a stream over the contents of this reader split on the specified byte. Read more
source§

impl<R> AsyncReadExt for R
where R: AsyncRead + ?Sized,

source§

fn read<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self>
where Self: Unpin,

Reads some bytes from the byte stream. Read more
source§

fn read_vectored<'a>( &'a mut self, bufs: &'a mut [IoSliceMut<'a>], ) -> ReadVectoredFuture<'a, Self>
where Self: Unpin,

Like read(), except it reads into a slice of buffers. Read more
source§

fn read_to_end<'a>( &'a mut self, buf: &'a mut Vec<u8>, ) -> ReadToEndFuture<'a, Self>
where Self: Unpin,

Reads the entire contents and appends them to a Vec. Read more
source§

fn read_to_string<'a>( &'a mut self, buf: &'a mut String, ) -> ReadToStringFuture<'a, Self>
where Self: Unpin,

Reads the entire contents and appends them to a String. Read more
source§

fn read_exact<'a>(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self>
where Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more
source§

fn take(self, limit: u64) -> Take<Self>
where Self: Sized,

Creates an adapter which will read at most limit bytes from it. Read more
source§

fn bytes(self) -> Bytes<Self>
where Self: Sized,

Converts this AsyncRead into a Stream of bytes. Read more
source§

fn chain<R: AsyncRead>(self, next: R) -> Chain<Self, R>
where Self: Sized,

Creates an adapter which will chain this stream with another. Read more
source§

fn boxed_reader<'a>(self) -> Pin<Box<dyn AsyncRead + Send + 'a>>
where Self: Sized + Send + 'a,

Boxes the reader and changes its type to dyn AsyncRead + Send + 'a. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.