Struct ringbuf::SharedRb

pub struct SharedRb<T, C: Container<T>> { /* private fields */ }

Ring buffer that could be shared between threads.

Implements Sync. And its Producer and Consumer implement Send.

use std::{thread, vec::Vec};
use ringbuf::SharedRb;

let (mut prod, mut cons) = SharedRb::<i32, Vec<_>>::new(256).split();
thread::spawn(move || {
    prod.push(123).unwrap();
})
.join();
thread::spawn(move || {
    assert_eq!(cons.pop().unwrap(), 123);
})
.join();

Implementations

impl<T> SharedRb<T, Vec<MaybeUninit<T>>>

pub fn new(capacity: usize) -> Self

Creates a new instance of a ring buffer.

Panics if capacity is zero.

impl<T, C: Container<T>> SharedRb<T, C>

pub unsafe fn from_raw_parts(container: C, head: usize, tail: usize) -> Self

Constructs ring buffer from container and counters.

Safety

The items in container inside head..tail range must be initialized, items outside this range must be uninitialized. head and tail values must be valid (see RbBase).

pub unsafe fn into_raw_parts(self) -> (C, usize, usize)

Destructures ring buffer into underlying container and head and tail counters.

Safety

Initialized contents of the container must be properly dropped.

pub fn split(self) -> (Producer<T, Arc<Self>>, Consumer<T, Arc<Self>>) where
    Self: Sized, 

Splits ring buffer into producer and consumer.

This method consumes the ring buffer and puts it on heap in Arc. If you don’t want to use heap the see Self::split_ref.

pub fn split_ref(&mut self) -> (Producer<T, &Self>, Consumer<T, &Self>) where
    Self: Sized, 

Splits ring buffer into producer and consumer without using the heap.

In this case producer and consumer stores a reference to the ring buffer, so you also need to store the buffer somewhere.

Trait Implementations

impl<T, const N: usize> Default for SharedRb<T, [MaybeUninit<T>; N]>

fn default() -> Self

Returns the “default value” for a type.

impl<T, C: Container<T>> Drop for SharedRb<T, C>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, C: Container<T>> RbBase<T> for SharedRb<T, C>

unsafe fn data(&self) -> &mut [MaybeUninit<T>]

Returns underlying raw ring buffer memory as slice.

fn capacity(&self) -> NonZeroUsize

Capacity of the ring buffer.

fn head(&self) -> usize

Head position.

fn tail(&self) -> usize

Tail position.

fn modulus(&self) -> NonZeroUsize

Modulus for head and tail values.

fn occupied_len(&self) -> usize

The number of items stored in the buffer at the moment.

fn vacant_len(&self) -> usize

The number of vacant places in the buffer at the moment.

fn is_empty(&self) -> bool

Checks if the occupied range is empty.

fn is_full(&self) -> bool

Checks if the vacant range is empty.

impl<T, C: Container<T>> RbRead<T> for SharedRb<T, C>

unsafe fn set_head(&self, value: usize)

Sets the new head position.

unsafe fn advance_head(&self, count: usize)

Move head position by count items forward.

fn occupied_ranges(&self) -> (Range<usize>, Range<usize>)

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

unsafe fn occupied_slices(
    &self
) -> (&mut [MaybeUninit<T>], &mut [MaybeUninit<T>])

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

unsafe fn skip(&self, count_or_all: Option<usize>) -> usize

Removes items from the head of ring buffer and drops them.

impl<T, C: Container<T>> RbWrite<T> for SharedRb<T, C>

unsafe fn set_tail(&self, value: usize)

Sets the new tail position.

unsafe fn advance_tail(&self, count: usize)

Move tail position by count items forward.

fn vacant_ranges(&self) -> (Range<usize>, Range<usize>)

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

unsafe fn vacant_slices(&self) -> (&mut [MaybeUninit<T>], &mut [MaybeUninit<T>])

Provides a direct access to the ring buffer vacant memory. Returns a pair of slices of uninitialized memory, the second one may be empty.

impl<T, C: Container<T>> Rb<T> for SharedRb<T, C>