Struct UndoReader

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

Undo reader supports unread(&u8) Useful when you are doing serialization/deserialization where you need to put data back (undo the read) You can use UndoReader as if it is a normal AsyncRead Additionally, UndoReader supports a limit as well. It would stop reading after limit is reached (EOF) Example:

// You can have rust code between fences inside the comments
// If you pass --test to `rustdoc`, it will even test it for you!
async fn do_test() -> Result<(), Box<dyn std::error::Error>> {
    use tokio::io::{AsyncRead,AsyncSeek,AsyncReadExt, AsyncSeekExt};
    let f = tokio::fs::File::open("input.txt").await?;
    let mut my_undo = crate::asyncio_utils::UndoReader::new(f, Some(10)); // only read 10 bytes
    let mut buff = vec![0u8; 10];
    let read_count = my_undo.read(&mut buff).await?;
    if read_count > 0 {
        // inspect the data read check if it is ok
        my_undo.unread(&mut buff[0..read_count]); // put all bytes back
    }
    let data = "XYZ".as_bytes();
    my_undo.unread(&data);
    // this should be 3 (the "XYZ" should be read here)
    let second_read_count = my_undo.read(&mut buff).await?;
    // this should be equal to read_count because it would have been reread here
    let third_read_count = my_undo.read(&mut buff).await?;
    // ...
    Ok(())
}

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
async fn do_test() -> Result<(), Box<dyn std::error::Error>> {
    let f = tokio::fs::File::open("input.txt").await?;
    let my_undo = crate::asyncio_utils::UndoReader::new(f, None);
    let (remaining, raw) = my_undo.destruct();
    // ...
    Ok(())
}
// 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.