Struct Emitted 

pub struct Emitted<'p> { /* private fields */ }

What came out of a pipeline, and how it is framed.

bytes is the whole emission and units is the pieces the segment asked for it to be delivered in. Unless a stage called Ctx::boundary there is exactly one unit and the two say the same thing, so a sink with no framing of its own (a byte stream, a file) can write bytes in one call and ignore units entirely.

Where units are observable they matter: on a datagram sink one unit is one message, and across a detached boundary one unit is one parcel and so one call to the segment below.

Implementations

impl<'p> Emitted<'p>

pub const fn whole(bytes: &'p [u8]) -> Self

One unit covering all of bytes, which is what an unframed chunk is.

pub const fn empty() -> Self

Nothing reached the end of the pipeline.

pub const fn bytes(&self) -> &'p [u8]

Everything emitted, concatenated.

pub const fn is_empty(&self) -> bool

pub const fn len(&self) -> usize

pub fn units(self) -> impl Iterator<Item = &'p [u8]>

Each unit, in order. Exactly one unit when nothing declared any.

Takes self by value so the iterator borrows the pipeline rather than this handle, which is what lets a caller iterate units while the emission is in flight.

Trait Implementations

impl<'p> Clone for Emitted<'p>

fn clone(&self) -> Emitted<'p>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'p> Copy for Emitted<'p>

impl<'p> Debug for Emitted<'p>

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

Formats the value using the given formatter.