Struct SseStream 

pub struct SseStream<T: TryStream> { /* private fields */ }

An asynchronous stream wrapper that parses SSE events from an underlying byte stream.

Implementations

impl<T: TryStream> SseStream<T>

pub fn disconnected() -> Self

Creates a new, disconnected SseStream.

A disconnected stream will immediately yield None (terminated) if polled. This constructor is primarily useful when you need to store the SseStream inside a struct before the network connection is established.

To make the stream active, you must attach an inner stream using attach().

Example

let mut stream = SseStream::disconnected();

// ... later, when the network is ready:
let byte_stream = fetch_http_stream().await;
stream.attach(byte_stream);

pub fn with_decoder(decoder: SseDecoder) -> Self

Creates a disconnected stream initialized with a custom decoder.

See the disconnected() function for more information.

pub fn new(inner: T) -> Self

Creates a new SseStream wrapping the provided inner stream.

pub fn take_decoder(self) -> SseDecoder

Consumes the stream and returns the underlying state-machine decoder.

pub fn is_closed(&self) -> bool

Returns true if the stream is currently disconnected.

pub fn last_event_id(&self) -> Option<&Arc<str>>

Returns the current Last-Event-ID parsed by the underlying decoder.

pub fn close(&mut self)

Disconnects the inner stream while retaining the underlying parser’s state.

This drops the active network connection but safely preserves the most recently parsed Last-Event-ID within the decoder. This is the standard method to temporarily pause a stream or handle a dropped connection, allowing you to later resume exactly where you left off.

• To close the stream and inject a new ID for the next connection, use close_with_id().
• To close the stream and completely wipe the session state, use close_and_clear().

pub fn close_and_clear(&mut self)

Disconnects the stream and completely purges the underlying parser’s state.

This drops the inner stream, clears all internal byte buffers, and permanently drops the currently tracked Last-Event-ID. It effectively returns the SseStream to the exact state it was in when initially created via disconnected().

• To close the stream and keep the current ID, use close().
• To close the stream and inject a new ID, use close_with_id().

pub fn close_with_id(&mut self, id: Option<Arc<str>>)

Disconnects the inner stream and explicitly overrides the underlying decoder’s Last-Event-ID in preparation for a future connection.

This is particularly useful in async contexts where you must drop the active stream, inject a new ID, and then yield back to the runtime before establishing a new network connection. The injected ID will be available immediately via last_event_id().

• To close the stream and keep the current ID, use close().
• To close the stream and completely wipe the session state, use close_and_clear().

pub fn attach(&mut self, inner: T)

Attaches a new inner stream to resume processing events.

This method resets the underlying parser’s buffers but retains the most recently received Last-Event-ID. It is the standard way to recover from a dropped network connection without missing any events.

If you need to manually inject a saved Last-Event-ID (e.g., when recovering an offline session from a database), use attach_with_id() instead.

pub fn attach_with_id(&mut self, inner: T, id: Option<Arc<str>>)

Attaches a new inner stream to resume processing, explicitly overriding the Last-Event-ID in the underlying decoder.

This method is primarily used when recovering an offline session where you need to initialize the stream with a saved ID right as you provide the new HTTP response stream.

If you just want to resume a dropped stream using the ID that the decoder has already tracked automatically, use attach().

Trait Implementations

impl<T: TryStream> FusedStream for SseStream<T>

where T::Ok: Buf,

fn is_terminated(&self) -> bool

Returns true if the stream should no longer be polled.

impl<T: TryStream> Stream for SseStream<T>

where T::Ok: Buf,

type Item = Result<SseEvent, SseStreamError<<T as TryStream>::Error>>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.

impl<'__pin, T: TryStream> Unpin for SseStream<T>

where PinnedFieldsOf<__Origin<'__pin, T>>: Unpin,