Struct EventBuf 

pub struct EventBuf<T: Copy, const N: usize> { /* private fields */ }

Bounded SPSC event buffer with backpressure.

When the buffer is full, Producer::push returns Err(val) instead of overwriting, giving the producer a chance to retry, drop, or log. The consumer drains items with Consumer::pop or Consumer::drain, and can inspect the oldest item with Consumer::peek without consuming it.

Panics

• EventBuf::new() fails to compile (const assertion) when N == 0 on the host path; under Loom it panics at runtime.
• Handle acquisition never panics: EventBuf::try_producer / EventBuf::try_consumer return None while a handle of that kind is active. (The panicking producer() / consumer() were removed in 0.3.0.)

Implementations

impl<T: Copy, const N: usize> EventBuf<T, N>

pub const fn new() -> Self

Create a new, empty event buffer.

On the normal (non-Loom) build this is a const fn, so the buffer can be placed in a static: static BUF: EventBuf<u32, 64> = EventBuf::new();. Under --cfg loom it is deliberately non-const — Loom’s atomics are not const-constructible.

Capacity 0 is a build failure

The N > 0 check is a const assertion, so a zero-capacity buffer cannot be constructed at all – there is no runtime panic left to catch, and therefore no way to write the negative case as a #[test]. This compile_fail doctest is that coverage, and pinning the error code keeps it honest: without it the test would also pass on a typo.

let _ = ph_eventing::EventBuf::<u32, 0>::new();

Panics

Does not panic on the host path. Under Loom, where new is non-const, N == 0 is a runtime assertion instead.

pub const fn capacity(&self) -> usize

Maximum number of items the buffer can hold.

pub fn len(&self) -> usize

Approximate number of items currently buffered.

Returns a consistent (tail, head) snapshot. The value may still be stale by the time the caller acts on it, but it will never spuriously exceed capacity.

This never blocks: it makes a bounded number of attempts and then falls back to a clamped estimate, so a busy consumer cannot stall the caller.

pub fn is_empty(&self) -> bool

Returns true if the buffer contains no items (approximate).

pub fn is_full(&self) -> bool

Returns true if the buffer is at capacity (approximate).

pub fn try_producer(&self) -> Option<Producer<'_, T, N>>

Try to create the producer handle.

Returns None if a producer is already active — never panics. On the targets this crate exists for a panic is a reset, so fallible bring-up is the only handle-acquisition API. (The panicking producer() was deprecated in 0.2.0 and removed in 0.3.0.)

pub fn try_consumer(&self) -> Option<Consumer<'_, T, N>>

Try to create the consumer handle.

Returns None if a consumer is already active — never panics. On the targets this crate exists for a panic is a reset, so fallible bring-up is the only handle-acquisition API. (The panicking consumer() was deprecated in 0.2.0 and removed in 0.3.0.)

Trait Implementations

impl<T: Copy, const N: usize> Debug for EventBuf<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Copy, const N: usize> Default for EventBuf<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Copy + Send, const N: usize> Sync for EventBuf<T, N>