Struct DrainFanIn 

pub struct DrainFanIn<S, const N: usize> { /* private fields */ }

Fixed-arity N→1 zero-copy merge over [S; N]. Round-robin fair; ends when every source has drained. Shares the FSM shape of crate::pipe::fan_in::FanIn (cursor + live-set + remaining) but drives sources push-style so items borrow source slots without copying. No_std + no-alloc.

Implementations

impl<S, const N: usize> DrainFanIn<S, N>

pub fn new(sources: [S; N]) -> Self

Merge sources. All start live.

pub fn live_count(&self) -> usize

Sources not yet permanently drained.

pub fn drain_each<F>(&mut self, visitor: F) -> DrainState

where S: DrainSource, F: FnMut(&S::Item) -> ControlFlow<()>,

Visit the live sources once each, round-robin from the cursor, draining each fully (the burst pattern: a source emits its ready items per visit, then the next source). Items are read in-place — zero copy. Returns when the visitor breaks (backpressure → DrainState::More, resuming at the same source next call) or every source has drained.

Cross-call fairness: the cursor advances by one each call so a perpetually busy source can’t permanently win the first slot. impl FnMut monomorphises the consumer; the per-source drain_ready takes the &mut dyn FnMut, so the only vtable hop is once per source, not per item.

Trait Implementations

impl<S: DrainSource, const N: usize> DrainSource for DrainFanIn<S, N>

type Item = <S as DrainSource>::Item

The item lent to the visitor. ?Sized so it can be a [u8] slot view.

fn drain_ready( &mut self, visitor: &mut dyn FnMut(&Self::Item) -> ControlFlow<()>, ) -> DrainState

Drain all currently-ready items, calling visitor on each (borrowed) item in order. No alloc, no syscall, no waker on the hot path.