Struct spms_ring::SpmsRing

pub struct SpmsRing<T, N: ArrayLength<T>> { /* fields omitted */ }

This is a ring buffer intended for use in pub-sub applications. That is, a single publisher writes items to the buffer, and multiple subscribers can read items from the buffer. When a write to the fixed-size circular buffer overflows, the oldest items in the buffer are overwritten. Reading items from the buffer does not remove them from the buffer (as it would from a Queue): instead, Subscribers use ReadTokens to track which items they have already read, and use nonblocking read to read the next available item.

Note that the fixed buffer length must always be a power of two.

Implementations

impl<T, N> SpmsRing<T, N> where
    T: Default + Copy + Debug,
    N: ArrayLength<T>, 

pub fn subscribe(&self) -> ReadToken

Get a read token for subsequent reads

pub fn publish(&mut self, val: &T)

Publish a single item

pub fn read_next(&self, token: &mut ReadToken) -> Result<T, ()>

Read an item from the buffer. Returns either an available item or WouldBlock There are only three possible actions:

• Read from the next available index after index in read token
• Read from oldest index (the read token might be stale)
• nb::Error::WouldBlock

pub fn empty(&self) -> bool

Is the queue empty?

pub fn at_capacity(&self) -> bool

Is this buffer filled to capacity? In other words, will a subsequent publish overwrite the oldest item in the buffer?

pub fn available(&self) -> usize

How many total items are available to read?

Trait Implementations

impl<T, N> Default for SpmsRing<T, N> where
    T: Default + Copy + Debug,
    N: ArrayLength<T>, 

fn default() -> Self

This is how the buffer should be created