Struct async_ringbuf::rb::AsyncRb

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

Implementations

impl<T> AsyncRb<Vec<MaybeUninit<T>, Global>>

pub fn new(cap: usize) -> Self

impl<S: Storage> AsyncRb<S>

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

Trait Implementations

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

unsafe fn set_read_index(&self, value: usize)

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 try_pop(&mut self) -> Option<Self::Item>

Removes latest item from the ring buffer and returns it.

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.

impl<T, const N: usize> Default for AsyncRb<Static<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

fn write_index(&self) -> usize

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

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)

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) -> usizewhere 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.

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

unsafe fn hold_read(&self, flag: bool)

unsafe fn hold_write(&self, flag: bool)

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.

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

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

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

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

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

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

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

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

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