Struct SseParser 

pub struct SseParser { /* private fields */ }

Stateful SSE byte-stream parser.

Feed bytes with SseParser::feed and poll complete frames with SseParser::next_frame.

The parser buffers bytes internally until a complete line is available, then processes each line according to the SSE spec.

Memory limits

The parser enforces a configurable maximum event size (default 16 MiB) to prevent unbounded memory growth from malicious or malformed streams. When the limit is exceeded, the current event is discarded and an error is queued. A single line is refused the same way as soon as it grows past the longest line an in-limit event can hold (the limit plus retry: ), so a peer that never sends a newline gets an error rather than silence, and the parser holds no more than that of it. Use SseParser::with_max_event_size to configure the limit.

The internal frame queue is also bounded (default 4096 frames) to prevent OOM from streams that produce many oversized-event errors without the consumer draining them.

Implementations

impl SseParser

pub fn new() -> SseParser

Creates a new, empty SseParser with default limits (4 MiB max event size).

pub fn with_max_event_size(max_event_size: usize) -> SseParser

Creates a new SseParser with a custom maximum event size.

Events exceeding this limit will be discarded and an error queued.

pub const fn with_max_queued_frames(self, max: usize) -> SseParser

Sets the maximum number of frames that can be buffered before the oldest frame is dropped. Prevents unbounded memory growth if the consumer is slower than the producer.

pub fn pending_count(&self) -> usize

Returns the number of complete frames waiting to be consumed.

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

Feeds raw bytes from the SSE stream into the parser.

After calling feed, call SseParser::next_frame repeatedly until it returns None to consume all complete frames.

pub fn incomplete_event_len(&self) -> Option<usize>

Bytes of an event that has started but not been dispatched: data: lines still waiting for their blank line, plus an unterminated line that is not a comment. None when there is none.

What is left here when the byte stream ends is an event the server did not finish writing. The SSE specification discards it at end of stream, and so does the parser; this is how a caller finds out that it did, instead of the loss passing unseen. An unterminated comment (: keep-alive cut off before its newline) carries no event and is not counted.

pub fn next_frame(&mut self) -> Option<Result<SseFrame, SseParseError>>

Returns the next complete SseFrame, or None if none are ready.

Returns Err if an event exceeded the maximum size limit.

Trait Implementations

impl Debug for SseParser

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

Formats the value using the given formatter.

impl Default for SseParser

fn default() -> SseParser

Returns the “default value” for a type.