Struct PrefixedReadIo

pub struct PrefixedReadIo<I, P> { /* private fields */ }

PrefixedReadIO facilitates the addition of a prefix to an IO stream, enabling stream rewinding and peeking capabilities. Subsequent reads will preserve access to the original stream contents.

async fn demo<T>(mut stream: T)
where
    T: AsyncReadRent + AsyncWriteRent,
{
    // let stream = b"hello world";
    let buf = vec![0 as u8; 6];
    let (_, buf) = stream.read_exact(buf).await;
    assert_eq!(buf, b"hello ");

    let prefix_buf = std::io::Cursor::new(buf);
    let mut pio = PrefixedReadIo::new(stream, prefix_buf);

    let buf = vec![0 as u8; 11];
    let (_, buf) = pio.read_exact(buf).await;
    assert_eq!(buf, b"hello world");
}

Implementations

impl<I, P> PrefixedReadIo<I, P>

pub const fn new(io: I, prefix: P) -> Self

Create a PrefixedIo with given io and read prefix.

pub const fn prefix_finished(&self) -> bool

If the prefix has read to eof

pub fn into_inner(self) -> I

Into inner

Trait Implementations

impl<I: AsyncReadRent, P: Read> AsyncReadRent for PrefixedReadIo<I, P>

async fn read<T: IoBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Reads bytes from this source into the provided buffer, returning the number of bytes read.

async fn readv<T: IoVecBufMut>(&mut self, buf: T) -> BufResult<usize, T>

Similar to read, but reads data into a slice of buffers.

impl<I: AsyncWriteRent, P> AsyncWriteRent for PrefixedReadIo<I, P>

fn write<T: IoBuf>( &mut self, buf: T, ) -> impl Future<Output = BufResult<usize, T>>

Writes the contents of a buffer into this writer, returning the number of bytes written.

fn writev<T: IoVecBuf>( &mut self, buf_vec: T, ) -> impl Future<Output = BufResult<usize, T>>

This function attempts to write the entire contents of buf_vec, but the write may not fully succeed, and it might also result in an error. The bytes will be written starting at the specified offset.

fn flush(&mut self) -> impl Future<Output = Result<()>>

Flushes this output stream, ensuring that all buffered content is successfully written to its destination.

fn shutdown(&mut self) -> impl Future<Output = Result<()>>

Shuts down the output stream, ensuring that the value can be cleanly dropped.

impl<I: CancelableAsyncReadRent, P: Read> CancelableAsyncReadRent for PrefixedReadIo<I, P>

async fn cancelable_read<T: IoBufMut>( &mut self, buf: T, c: CancelHandle, ) -> BufResult<usize, T>

Same as read(2)

async fn cancelable_readv<T: IoVecBufMut>( &mut self, buf: T, c: CancelHandle, ) -> BufResult<usize, T>

Same as readv(2)

impl<I: CancelableAsyncWriteRent, P> CancelableAsyncWriteRent for PrefixedReadIo<I, P>

fn cancelable_write<T: IoBuf>( &mut self, buf: T, c: CancelHandle, ) -> impl Future<Output = BufResult<usize, T>>

Same as write(2)

fn cancelable_writev<T: IoVecBuf>( &mut self, buf_vec: T, c: CancelHandle, ) -> impl Future<Output = BufResult<usize, T>>

Same as writev(2)

fn cancelable_flush( &mut self, c: CancelHandle, ) -> impl Future<Output = Result<()>>

Flush buffered data if needed

fn cancelable_shutdown( &mut self, c: CancelHandle, ) -> impl Future<Output = Result<()>>

Same as shutdown

impl<I, P> Split for PrefixedReadIo<I, P>

where I: Split,

implement unsafe Split for PrefixedReadIo, it’s safe because read/write are independent, we can safely split them into two I/O parts.