Struct UndoReader

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

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§

Source§

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

Source

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

Source

pub fn limit(&self) -> usize

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

Source

pub fn count_unread(&self) -> usize

Count the number of bytes in the unread buffer

Source

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

Source

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§

Source§

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

Implementation of AsyncRead for UndoReader

Source§

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

Attempts to read from the AsyncRead into buf. Read more

Auto Trait Implementations§

§

impl<T> Freeze for UndoReader<T>
where T: Freeze,

§

impl<T> RefUnwindSafe for UndoReader<T>
where T: RefUnwindSafe,

§

impl<T> Send for UndoReader<T>
where T: Send,

§

impl<T> Sync for UndoReader<T>
where T: Sync,

§

impl<T> Unpin for UndoReader<T>

§

impl<T> UnwindSafe for UndoReader<T>
where T: 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> AsyncReadExt for R
where R: AsyncRead + ?Sized,

Source§

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

Creates a new AsyncRead instance that chains this stream with next. Read more
Source§

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

Pulls some bytes from this source into the specified buffer, returning how many bytes were read. Read more
Source§

fn read_buf<'a, B>(&'a mut self, buf: &'a mut B) -> ReadBuf<'a, Self, B>
where Self: Unpin, B: BufMut + ?Sized,

Pulls some bytes from this source into the specified buffer, advancing the buffer’s internal cursor. Read more
Source§

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

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

fn read_u8(&mut self) -> ReadU8<&mut Self>
where Self: Unpin,

Reads an unsigned 8 bit integer from the underlying reader. Read more
Source§

fn read_i8(&mut self) -> ReadI8<&mut Self>
where Self: Unpin,

Reads a signed 8 bit integer from the underlying reader. Read more
Source§

fn read_u16(&mut self) -> ReadU16<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_i16(&mut self) -> ReadI16<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_u32(&mut self) -> ReadU32<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_i32(&mut self) -> ReadI32<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_u64(&mut self) -> ReadU64<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_i64(&mut self) -> ReadI64<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_u128(&mut self) -> ReadU128<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_i128(&mut self) -> ReadI128<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in big-endian order from the underlying reader. Read more
Source§

fn read_f32(&mut self) -> ReadF32<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in big-endian order from the underlying reader. Read more
Source§

fn read_f64(&mut self) -> ReadF64<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in big-endian order from the underlying reader. Read more
Source§

fn read_u16_le(&mut self) -> ReadU16Le<&mut Self>
where Self: Unpin,

Reads an unsigned 16-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_i16_le(&mut self) -> ReadI16Le<&mut Self>
where Self: Unpin,

Reads a signed 16-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_u32_le(&mut self) -> ReadU32Le<&mut Self>
where Self: Unpin,

Reads an unsigned 32-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_i32_le(&mut self) -> ReadI32Le<&mut Self>
where Self: Unpin,

Reads a signed 32-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_u64_le(&mut self) -> ReadU64Le<&mut Self>
where Self: Unpin,

Reads an unsigned 64-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_i64_le(&mut self) -> ReadI64Le<&mut Self>
where Self: Unpin,

Reads an signed 64-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_u128_le(&mut self) -> ReadU128Le<&mut Self>
where Self: Unpin,

Reads an unsigned 128-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_i128_le(&mut self) -> ReadI128Le<&mut Self>
where Self: Unpin,

Reads an signed 128-bit integer in little-endian order from the underlying reader. Read more
Source§

fn read_f32_le(&mut self) -> ReadF32Le<&mut Self>
where Self: Unpin,

Reads an 32-bit floating point type in little-endian order from the underlying reader. Read more
Source§

fn read_f64_le(&mut self) -> ReadF64Le<&mut Self>
where Self: Unpin,

Reads an 64-bit floating point type in little-endian order from the underlying reader. Read more
Source§

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

Reads all bytes until EOF in this source, placing them into buf. Read more
Source§

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

Reads all bytes until EOF in this source, appending them to buf. Read more
Source§

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

Creates an adaptor which reads at most limit bytes from it. 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>,

Source§

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>,

Source§

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.