Struct asyncio_utils::UndoReader

pub struct UndoReader<T>where
    T: AsyncRead + Unpin,{ /* private fields */ }

// You can have rust code between fences inside the comments
// If you pass --test to `rustdoc`, it will even test it for you!
use asyncio_utils::UndoReader;
let input = tokio::fs::File::open("test.data").unwrap();
let first_10_bytes_reader = UndoReader::wrap(input, Some(10)); // limit to first 10 bytes, EOF afterwards
let my_data = first_10_bytes_reader.read(buf).await?;
// use my_data
 
let read_every_thing = UndoReader::wrap(input, None); // No limit (usize::max actually)
 
first_10_bytes_reader.unread(&my_data[4..7]); // Put back the 3 bytes back to the undo reader
 
first_10_bytes_reader.read(&mut buf); // definitely will be the 3 bytes you put back just now. Unless your buffer is too small

Implementations

impl<T> UndoReader<T>where T: AsyncRead + Unpin,

pub fn destruct(self) -> (Vec<u8>, T)

Destruct this UndoReader.

Returns the buffer that has been unread but has not been consumed as well as the raw AsyncRead Example:

// initialize my_undo
let (remaining, raw) = my_undo.destruct();
// remaining is the bytes to be consumed.
// raw is the raw AsyncRead

The UndoReader can’t be used anymore after this call

pub fn limit(&self) -> usize

Get the limit of the UndoReader If the limit was None, this would be the usize’s max value.

pub fn count_unread(&self) -> usize

Count the number of bytes in the unread buffer

pub fn new(src: T, limit: Option<usize>) -> UndoReader<T>

Create new UndoReader with limitation. If limit is None, std::usize::MAX will be used If limit is Some(limit:usize), the limit will be used

pub fn unread(&mut self, data: &[u8]) -> &mut Self

Put data for unread so it can be read again.

Reading of unread data does not count towards the limit because we assume you unconsumed something you consumed in the first place.

However, practically, you can arbitrarily unread any data. So the limit may break the promise in such cases

Trait Implementations

impl<T> AsyncRead for UndoReader<T>where T: AsyncRead + Unpin,

Implementation of AsyncRead for UndoReader

fn poll_read( self: Pin<&mut Self>, ctx: &mut Context<'_>, data: &mut ReadBuf<'_> ) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf.