Struct aiowrap::DequeReader

pub struct DequeReader<R> { /* fields omitted */ }

An interface like io::BufReader, but extra data can be repeatedly added.

let mut m = DequeReader::new(io::Cursor::new(b"hello world"));
// gather more and more data
while m.read_more().await.expect("no io errors") {
    // until we find an 'r'
    if let Some(r) = m.buffer().iter().position(|&c| c == b'r') {
        // then discard everything up to that point
        Pin::new(&mut m).consume(r);
        return;
    }
}
panic!("reached eof")

Methods

impl<R> DequeReader<R>

pub fn new(inner: R) -> DequeReader<R>

Wrap a reader, without allocating a buffer. The buffer will be allocated, and grown, on use.

pub fn with_capacity(inner: R, n: usize) -> DequeReader<R>

Wrap a reader, pre-allocating a buffer of a specific size. The buffer will be grown on use.

Note: SliceDeque has stringent, platform dependent rules around the buffer size, so the resulting buffer size may be wildly different.

pub fn get_ref(&self) -> &R

Gets a reference to the underlying reader.

It is inadvisable to directly read from the underlying reader.

pub fn get_mut(&mut self) -> &mut R

Gets a mutable reference to the underlying reader.

It is inadvisable to directly read from the underlying reader.

pub fn get_pin_mut(self: Pin<&mut Self>) -> Pin<&mut R>

Gets a pinned mutable reference to the underlying reader.

It is inadvisable to directly read from the underlying reader.

pub fn into_inner(self) -> R

Consumes this, returning the underlying reader.

Note that any leftover data in the internal buffer is lost.

impl<R: AsyncRead> DequeReader<R>

pub fn poll_read_more(
    self: Pin<&mut Self>,
    cx: &mut Context
) -> Poll<Result<bool>>

Attempt a large read against the inner reader.

If a byte could not be read as we are at the end of the stream, return false.

pub fn buffer(&self) -> &[u8]

Access the inner buffer directly, without attempting any reads.

impl<R: Unpin + AsyncRead> DequeReader<R>

pub async fn read_more<'_>(&'_ mut self) -> Result<bool>

Resolves when we can read at least one extra byte into the inner reader, typically many more, returning true until we are at eof.

Trait Implementations

impl<R: AsyncRead> AsyncBufRead for DequeReader<R>

fn poll_fill_buf<'a>(
    self: Pin<&'a mut Self>,
    cx: &mut Context
) -> Poll<Result<&'a [u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to [poll_read].

impl<R: AsyncRead> AsyncRead for DequeReader<R>

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<W: AsyncWrite> AsyncWrite for DequeReader<W>

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &[u8]
) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &[IoSlice]
) -> Poll<Result<usize>>

Attempt to write bytes from bufs into the object using vectored IO operations.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to close the object.

impl<'__pin, R> Unpin for DequeReader<R> where
    __Origin<'__pin, R>: Unpin,