Struct mini_io_queue::blocking::Reader
source · [−]pub struct Reader<S> { /* private fields */ }
blocking
only.Expand description
Receives items from the queue.
Values sent by the writer will be added to the end of the reader’s buffer, and capacity can be sent back to the writer from the start of the reader’s buffer to allow it to write more data.
Implementations
sourceimpl<S> Reader<S>
impl<S> Reader<S>
sourcepub fn is_writer_open(&self) -> bool
pub fn is_writer_open(&self) -> bool
Returns if the corresponding writer is still open.
If this is false
, unread data will still be available to read but a well-behaved writer
will not provide any new data.
sourcepub fn has_data(&self) -> bool
pub fn has_data(&self) -> bool
Returns if data is available in the reader’s buffer.
If this is true it is guaranteed that the next call to fill_buf
will return a non-empty
slice, unless consume
is called first.
Keep in mind that when using a reader and writer on separate threads, a reader that has no
data can receive data at any time - even between calls to has_data
and other functions.
sourcepub fn is_full(&self) -> bool
pub fn is_full(&self) -> bool
Returns if the buffer is full, i.e all space is allocated to the reader and any write operations will block.
If this is true a reader can only resume the writer by calling consume
to pass capacity
to the writer.
Keep in mind that when using a reader and writer on separate threads, a reader that is not
full can become full at any time - even between calls to is_full
and other functions.
sourcepub fn fill_buf<T>(&mut self) -> Region<'_, T> where
S: Storage<T>,
pub fn fill_buf<T>(&mut self) -> Region<'_, T> where
S: Storage<T>,
Attempt to read from the reader’s buffer, blocking to wait for more data if it is empty.
This function is a lower-level call. It needs to be paired with the consume
method to
function properly. When calling this method, none of the contents will be “read” in the
sense that later calling fill_buf
may return the same contents. As such, consume
must
be called with the number of bytes that are consumed from this buffer to ensure that the
items are never returned twice.
An empty buffer returned indicates that all data has been read and the writer has closed.
sourcepub fn consume(&mut self, amt: usize)
pub fn consume(&mut self, amt: usize)
Marks items at the start of the reader buffer as consumed, removing them from the slice
returned by fill_buf
and adding their capacity to the end of the writer’s buffer.
Since queues have a fixed underlying length, calling this is required to allow the transfer
of more data.
Panics
This function will panic if amt
is larger than the reader’s available data buffer.
sourcepub fn read<T>(&mut self, buf: &mut [T]) -> usize where
S: Storage<T>,
T: Clone,
pub fn read<T>(&mut self, buf: &mut [T]) -> usize where
S: Storage<T>,
T: Clone,
Pulls some items from this queue into the specified buffer, returning how many items were read.
This method will complete immediately if at least one item is available to read, otherwise it will block until some are available.
Return
It is guaranteed that the return value is <= buf.len()
.
A return value of 0
indicates one of these two scenarios:
- The writer has closed and all items have been read.
- The buffer specified had a length of 0.
sourcepub fn read_exact<T>(&mut self, buf: &mut [T]) -> Result<usize, ReadExactError> where
S: Storage<T>,
T: Clone,
pub fn read_exact<T>(&mut self, buf: &mut [T]) -> Result<usize, ReadExactError> where
S: Storage<T>,
T: Clone,
Reads the exact number of items required to fill buf
.
If the writer closes before the buffer is completely filled, an error of the kind
ReadExactError::WriterClosed
will be returned.
Return
If the return value is Ok(n)
, it is guaranteed that n == buf.len()
.
sourcepub fn close(&mut self)
pub fn close(&mut self)
Close the reader, indicating to the writer that no more data will be read.
Any in-progress writes or flushes on the writer will be interrupted, and any future operations will fail. Closing the reader multiple times has no effect.
Dropping the reader object will also close it.
Trait Implementations
sourceimpl<S> BufRead for Reader<S> where
S: Storage<u8>,
impl<S> BufRead for Reader<S> where
S: Storage<u8>,
sourcefn fill_buf(&mut self) -> Result<&[u8]>
fn fill_buf(&mut self) -> Result<&[u8]>
Returns the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more
sourcefn consume(&mut self, amt: usize)
fn consume(&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 read
. Read more
sourcefn has_data_left(&mut self) -> Result<bool, Error>
fn has_data_left(&mut self) -> Result<bool, Error>
buf_read_has_data_left
)Check if the underlying Read
has any data left to be read. Read more
1.0.0 · sourcefn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
fn read_until(
&mut self,
byte: u8,
buf: &mut Vec<u8, Global>
) -> Result<usize, Error>
Read all bytes into buf
until the delimiter byte
or EOF is reached. Read more
1.0.0 · sourcefn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until a newline (the 0xA
byte) is reached, and append
them to the provided buffer. You do not need to clear the buffer before
appending. Read more
sourceimpl<S> Read for Reader<S> where
S: Storage<u8>,
impl<S> Read for Reader<S> where
S: Storage<u8>,
sourcefn read(&mut self, buf: &mut [u8]) -> Result<usize>
fn read(&mut self, buf: &mut [u8]) -> Result<usize>
Pull some bytes from this source into the specified buffer, returning how many bytes were read. Read more
1.36.0 · sourcefn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
Like read
, except that it reads into a slice of buffers. Read more
sourcefn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector
)Determines if this Read
er has an efficient read_vectored
implementation. Read more
1.0.0 · sourcefn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>
Read all bytes until EOF in this source, placing them into buf
. Read more
1.0.0 · sourcefn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
Read all bytes until EOF in this source, appending them to buf
. Read more
1.6.0 · sourcefn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
Read the exact number of bytes required to fill buf
. Read more
sourcefn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
read_buf
)Pull some bytes from this source into the specified buffer. Read more
sourcefn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, buf: &mut ReadBuf<'_>) -> Result<(), Error>
read_buf
)Read the exact number of bytes required to fill buf
. Read more
1.0.0 · sourcefn by_ref(&mut self) -> &mut Self
fn by_ref(&mut self) -> &mut Self
Creates a “by reference” adaptor for this instance of Read
. Read more
Auto Trait Implementations
impl<S> RefUnwindSafe for Reader<S> where
S: RefUnwindSafe,
impl<S> Send for Reader<S> where
S: Send + Sync,
impl<S> Sync for Reader<S> where
S: Send + Sync,
impl<S> Unpin for Reader<S>
impl<S> UnwindSafe for Reader<S> where
S: RefUnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more