Struct BoundedQueue 

pub struct BoundedQueue<R: RingStorage> { /* private fields */ }

A bounded queue applying a FailMode on overflow, over any RingStorage. Construct it through a tier alias: StaticBoundedQueue (no-alloc) or HeapBoundedQueue (alloc).

Implementations

impl<R: RingStorage> BoundedQueue<R>

pub const fn from_storage(queue: R, fail_mode: FailMode) -> Self

Wrap an already-constructed storage with an overflow policy.

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn dropped(&self) -> u64

Total items dropped or refused on overflow since construction.

pub fn note_drop(&self)

Count one externally-decided drop. For a caller that applies its OWN overflow routing on top of try_enqueue (a dynamic per-item policy the fixed FailMode can’t express) and discards the handed-back item itself — this folds that drop into the same counter dropped reports, so the queue stays the single drop total.

pub fn enqueue(&self, item: R::Item) -> EnqueueOutcome

Enqueue under the configured FailMode, counting any drop.

pub fn try_enqueue(&self, item: R::Item) -> Result<(), R::Item>

Enqueue WITHOUT the fail policy: on a full ring the item is handed back via Err so a lossless producer-assist loop can make room and retry it rather than dropping it. Nothing is counted as dropped. #[inline] — this is an emit hot path (the telemetry recorder pushes through it per record), so it must collapse to the bare storage push.

pub fn enqueue_assisting<F>( &self, item: R::Item, on_full: F, ) -> Result<(), R::Item>

where F: FnMut() -> bool,

Enqueue, looping through a make-room step on a full ring until the item lands. on_full is the producer’s make-room action (e.g. drain + export a batch to free a slot); it returns true to keep trying, false to give up — in which case the un-enqueued item is handed back via Err. This is the shared producer-assist loop: a strictly-lossless caller passes an on_full that never gives up (and yields on a no-progress round); a bounded caller gives up and applies its own overflow policy to the Err. The loop itself neither counts nor blocks — any yield/park lives in on_full, so this stays no_std.

pub fn dequeue(&self) -> Option<R::Item>

Pop the oldest queued item, if any.

pub fn drain_into(&self, out: &mut [R::Item]) -> usize

Batch-pop up to out.len() items FIFO, returning the count filled. Uses the storage’s batch drain (the heap Ring’s prefetching Drainer).

impl<T, const N: usize> BoundedQueue<StaticRing<T, N>>

pub const fn new(fail_mode: FailMode) -> Self

A no-alloc bounded queue of capacity N (a power of two ≥ 2 — the StaticRing requirement). const, so the whole sink stack can live in a static on bare metal (see StaticRing::new); the loom build drops the const because loom’s atomics are not const-constructible.

impl<T> BoundedQueue<Ring<T>>

pub fn new(capacity: usize, fail_mode: FailMode) -> Self

A heap-backed bounded queue holding at most capacity items (rounded up to a power of two, minimum 2).