Type Alias Cons

pub type Cons<R> = Direct<R, false, true>;

Consumer of a ring buffer.

Aliased Type

struct Cons<R> { /* private fields */ }

Trait Implementations

impl<R: RbRef> Consumer for Cons<R>

unsafe fn set_read_index(&self, value: usize)

Set read index.

unsafe fn advance_read_index(&self, count: usize)

Moves read pointer by count places forward.

fn occupied_slices( &self, ) -> (&[MaybeUninit<Self::Item>], &[MaybeUninit<Self::Item>])

Provides a direct access to the ring buffer occupied memory. The difference from Self::as_slices is that this method provides slices of MaybeUninit, so items may be moved out of slices.

unsafe fn occupied_slices_mut( &mut self, ) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>])

Provides a direct mutable access to the ring buffer occupied memory.

fn as_slices(&self) -> (&[Self::Item], &[Self::Item])

Returns a pair of slices which contain, in order, the contents of the ring buffer.

fn as_mut_slices(&mut self) -> (&mut [Self::Item], &mut [Self::Item])

Returns a pair of mutable slices which contain, in order, the contents of the ring buffer.

fn first(&self) -> Option<&Self::Item>

Returns a reference to the eldest item in the ring buffer, if exists.

fn first_mut(&mut self) -> Option<&mut Self::Item>

Returns a mutable reference to the eldest item in the ring buffer, if exists.

fn last(&self) -> Option<&Self::Item>

Returns a reference to the most recent item in the ring buffer, if exists.

fn last_mut(&mut self) -> Option<&mut Self::Item>

Returns a mutable reference to the most recent item in the ring buffer, if exists.

fn try_pop(&mut self) -> Option<Self::Item>

Removes the eldest item from the ring buffer and returns it.

fn try_peek(&self) -> Option<&Self::Item>

Returns the reference to the eldest item without removing it from the buffer.

fn peek_slice_uninit(&self, elems: &mut [MaybeUninit<Self::Item>]) -> usize

Copies items from the ring buffer to an uninit slice without removing them from the ring buffer.

fn peek_slice(&self, elems: &mut [Self::Item]) -> usize

where Self::Item: Copy,

Copies items from the ring buffer to a slice without removing them from the ring buffer.

fn pop_slice_uninit(&mut self, elems: &mut [MaybeUninit<Self::Item>]) -> usize

Removes items from the ring buffer and writes them into an uninit slice.

fn pop_slice(&mut self, elems: &mut [Self::Item]) -> usize

where Self::Item: Copy,

Removes items from the ring buffer and writes them into a slice.

fn pop_iter(&mut self) -> PopIter<'_, Self>

Returns an iterator that removes items one by one from the ring buffer.

fn iter(&self) -> Iter<'_, Self>

Returns a front-to-back iterator containing references to items in the ring buffer.

fn iter_mut(&mut self) -> IterMut<'_, Self>

Returns a front-to-back iterator that returns mutable references to items in the ring buffer.

fn skip(&mut self, count: usize) -> usize

Removes at most count and at least min(count, Self::len()) items from the buffer and safely drops them.

fn clear(&mut self) -> usize

Removes all items from the buffer and safely drops them.

fn write_into<S: Write>( &mut self, writer: &mut S, count: Option<usize>, ) -> Option<Result<usize>>

where Self: Consumer<Item = u8>,

Removes at most first count bytes from the ring buffer and writes them into a Write instance. If count is None then as much as possible bytes will be written.

impl<R: RbRef> IntoIterator for Cons<R>

where Self: Sized,

type Item = <Direct<R, false, true> as Observer>::Item

The type of the elements being iterated over.

type IntoIter = IntoIter<Direct<R, false, true>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<R: RbRef> Read for Cons<R>

where Self: Consumer<Item = u8>,

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.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

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

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

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

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.