Struct AsyncRb

pub struct AsyncRb<S: Storage> { /* private fields */ }

Implementations

impl<T> AsyncRb<Heap<T>>

pub fn new(cap: usize) -> Self

impl<S: Storage> AsyncRb<S>

pub fn from(base: SharedRb<S>) -> Self

Trait Implementations

impl<S: Storage> AsMut<AsyncRb<S>> for AsyncRb<S>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S: Storage> AsRef<AsyncRb<S>> for AsyncRb<S>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Storage> Consumer for AsyncRb<S>

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) -> Chain<Iter<'_, Self::Item>, Iter<'_, Self::Item>>

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

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

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>( &mut self, writer: &mut S, count: Option<usize>, ) -> Option<Result<usize, Error>>

where S: Write, 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<T, const N: usize> Default for AsyncRb<Array<T, N>>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Storage> Observer for AsyncRb<S>

type Item = <S as Storage>::Item

fn capacity(&self) -> NonZeroUsize

Capacity of the ring buffer.

fn read_index(&self) -> usize

Index of the last item in the ring buffer.

fn write_index(&self) -> usize

Index of the next empty slot in the ring buffer.

unsafe fn unsafe_slices( &self, start: usize, end: usize, ) -> (&[MaybeUninit<S::Item>], &[MaybeUninit<S::Item>])

Get slice between start and end indices.

unsafe fn unsafe_slices_mut( &self, start: usize, end: usize, ) -> (&mut [MaybeUninit<S::Item>], &mut [MaybeUninit<S::Item>])

Get mutable slice between start and end indices.

fn read_is_held(&self) -> bool

Whether read end is held by consumer.

fn write_is_held(&self) -> bool

Whether write end is held by producer.

fn occupied_len(&self) -> usize

The number of items stored in the buffer.

fn vacant_len(&self) -> usize

The number of remaining free places in the buffer.

fn is_empty(&self) -> bool

Checks if the ring buffer is empty.

fn is_full(&self) -> bool

Checks if the ring buffer is full.

impl<S: Storage> Producer for AsyncRb<S>

unsafe fn set_write_index(&self, value: usize)

Set read index.

unsafe fn advance_write_index(&self, count: usize)

Moves write pointer by count places forward.

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

Provides a direct access to the ring buffer vacant memory.

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

Mutable version of Self::vacant_slices.

fn try_push(&mut self, elem: Self::Item) -> Result<(), Self::Item>

Appends an item to the ring buffer.

fn push_iter<I>(&mut self, iter: I) -> usize

where I: Iterator<Item = Self::Item>,

Appends items from an iterator to the ring buffer. Elements that haven’t been added to the ring buffer remain in the iterator.

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

where Self::Item: Copy,

Appends items from slice to the ring buffer.

fn read_from<S>( &mut self, reader: &mut S, count: Option<usize>, ) -> Option<Result<usize, Error>>

where S: Read, Self: Producer<Item = u8>,

Reads at most count bytes from Read instance and appends them to the ring buffer. If count is None then as much as possible bytes will be read.

impl<S: Storage> RingBuffer for AsyncRb<S>

unsafe fn hold_read(&self, flag: bool) -> bool

Tell whether read end of the ring buffer is held by consumer or not.

unsafe fn hold_write(&self, flag: bool) -> bool

Tell whether write end of the ring buffer is held by producer or not.

fn push_overwrite(&mut self, elem: Self::Item) -> Option<Self::Item>

Pushes an item to the ring buffer overwriting the latest item if the buffer is full.

fn push_iter_overwrite<I>(&mut self, iter: I)

where I: Iterator<Item = Self::Item>,

Appends items from an iterator to the ring buffer.

fn push_slice_overwrite(&mut self, elems: &[Self::Item])

where Self::Item: Copy,

Appends items from slice to the ring buffer overwriting existing items in the ring buffer.

impl<S: Storage> Split for AsyncRb<S>

type Prod = AsyncWrap<Arc<AsyncRb<S>>, true, false>

Producer type.

type Cons = AsyncWrap<Arc<AsyncRb<S>>, false, true>

Consumer type.

fn split(self) -> (Self::Prod, Self::Cons)

Perform splitting.

impl<S: Storage> SplitRef for AsyncRb<S>

type RefProd<'a> = AsyncWrap<&'a AsyncRb<S>, true, false> where Self: 'a

Ref producer type.

type RefCons<'a> = AsyncWrap<&'a AsyncRb<S>, false, true> where Self: 'a

Ref consumer type.

fn split_ref(&mut self) -> (Self::RefProd<'_>, Self::RefCons<'_>)

Perform splitting by reference.

impl<S: Storage> Unpin for AsyncRb<S>