Struct Decoder

Source

pub struct Decoder<P, S> { /* private fields */ }

Expand description

Owned-buffer streaming decoder, parameterised on the Partial type.

Accepts bytes via feed and yields decoded values via next. A None from next means “need more bytes, call feed again” - malformed packets are silently skipped (the framed bytes are drained to guarantee forward progress).

§Example

// fresh mode (no in-flight partial): seek sentinel + decode framed body
let mut dec = Decoder::<<MyPacket as DecodePartial<&[u8]>>::Partial>::new();
let mut scratch = [0u8; 2048];
loop {
    let n = socket.recv(&mut scratch)?;
    dec.feed(&scratch[..n]);
    while let Some(pkt) = dec.next() {
        handle(pkt);
    }
}

// resume mode: handed back from `Packet::NeedMore`
match MyPacket::decode_partial(&mut input) {
    Ok(Packet::Ready(t)) => use_packet(t),
    Ok(Packet::NeedMore(partial)) => {
        let mut dec = Decoder::new();
        dec.feed(more_bytes);
        while let Some(pkt) = dec.next() {
            use_packet(pkt);
            break;
        }
    }
    Err(label) => report(label),
}

Implementations§

Source §

impl<P, S> Decoder<P, S>

Decoder implementation

Source

pub fn new() -> Self

Construct an empty decoder in fresh mode (no in-flight partial).

Source

pub fn with_capacity(cap: usize) -> Self

Construct an empty decoder with a pre-allocated buffer capacity, in fresh mode.

Source

pub fn buffered(&self) -> &[u8] ⓘ

The bytes currently buffered but not yet decoded. Useful for observability and diagnostics.

Source

pub fn partial(&self) -> Option<&P>

Borrow the in-flight partial, if any. Some only after the decoder was constructed from a Packet::NeedMore return and before the next Self::next completes the packet.

Source

pub fn into_partial(self) -> Option

Consume the decoder and return its in-flight partial, if any. Used by the derive-generated decode_partial wrapper to lift “input fully consumed, NeedMore returned” into a finalisation at the fresh-mode boundary.

Source

pub fn clear(&mut self)

Drop all buffered bytes and any in-flight partial. Call after a Malformed error if you want to resync cleanly rather than byte-walk through corrupt input.

Source

pub fn feed(&mut self, bytes: &[u8])

Append bytes to the internal buffer. Does not trigger decoding on its own - call next to try to consume complete values.

Source

pub fn iter(&mut self) -> DecoderIter<'_, P, S> ⓘ

Returns an iterator over the buffered values, consuming them as they are decoded

Source

pub fn next<T>(&mut self) -> Option<T>
where S: Stream, P: Partial<Final = T> + Default, Self: PartialIterator,

Decode the next complete value from the buffer, if one is available

Source §

impl<P, T> Decoder<P, &[u8]>
where P: Partial<Final = T> + Default, for<'a> T: DecodePartial<&'a [u8], Partial = P> + ResumePartial<&'a [u8]> + SeekSentinel<&'a [u8]>,

Decoder decoding implementation - resume mode

This is just the &u8 specialization of Decoder

When the decoder carries an in-flight partial, next resumes DecodePartial::decode_partial without re-seeking the sentinel: the partial state already lives past the framing.

Source

pub fn finish(self) -> Result<T, DecodeIterError>

Force-finalise the current partial. Use when the upstream signals “no more bytes coming” and you want the accumulated partial surfaced (or its required-field failure reported). The decoder is consumed; the buffered bytes are discarded.