Struct LimitSeekerReader

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

An AsyncRead + AsyncSeek wrapper It supports limit the bytes can be read. Typically used when you want to read a specific segments from a file

Example

 
async fn run_test() -> Result<(), Box<dyn std::error::Error>> {
    use tokio::io::SeekFrom;
    use tokio::io::{AsyncRead,AsyncSeek, AsyncReadExt, AsyncSeekExt};
    let f = tokio::fs::File::open("input.txt").await?;
    let read_from: u64 = 18; // start read from 18'th byte
    let mut lsr = crate::asyncio_utils::LimitSeekerReader::new(f, Some(20)); // read up to 20 bytes
    lsr.seek(SeekFrom::Start(read_from)); // do seek
 
    let mut buf = vec![0u8; 1024];
    lsr.read(&mut buf); // read it
    return Ok(());
}

Implementations

impl<T> LimitSeekerReader<T>

where T: AsyncRead + AsyncSeek + Unpin,

Implement a limit reader for AsyncRead and AsyncSeek together. Typically a file Note that if your seek does not affect total reads. You can seek with positive/negative from current/begin of file/end of file, but it does not change the total bytes would be read from the reader.

This is a little bit weird though. Typically what you want to do is just seek before reading.

This is useful when you want to service Http Get with Range requests.

You open tokio::fs::File you seek the position you set limit on number of bytes to read you start reading and serving.

pub fn destruct(self) -> (usize, T)

Destruct the LimitSeekerReader and get the bytes read so far and the original reader Returns the size read and the original reader.

You can’t use the LimitSeekerReader after this call

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

Create new LimitSeekerReader from another AsyncRead + AsyncSeek (typically file)

Argument src is the underlying reader + seeker limit is the byte limit. Node that the limit can be Some(limit) None -> No limit (std::usize::MAX)

Trait Implementations

impl<T> AsyncRead for LimitSeekerReader<T>

where T: AsyncRead + AsyncSeek + Unpin,

Implementation of AsyncRead

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

Attempts to read from the AsyncRead into buf.

impl<T> AsyncSeek for LimitSeekerReader<T>

where T: AsyncRead + AsyncSeek + Unpin,

Implementation of AsyncSeek

fn start_seek(self: Pin<&mut Self>, from: SeekFrom) -> Result<(), Error>

Attempts to seek to an offset, in bytes, in a stream.

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

Waits for a seek operation to complete.