Struct Updates 

pub struct Updates { /* private fields */ }

The stream of one subscription’s events.

Returned by Client::subscribe. It implements futures_util::Stream, so the usual combinators work and the plain shape is a while let loop:

use futures_util::StreamExt;
use lightstreamer_rs::SubscriptionEvent;

while let Some(event) = updates.next().await {
    if let SubscriptionEvent::Update(update) = event {
        println!("{}: {:?}", update.item_name(), update.changed_fields());
    }
}

Dropping this stream unsubscribes

There is no deregistration dance: drop the Updates and the client sends the unsubscription for you. The request goes out asynchronously — the drop itself does not block and cannot fail — so a UNSUB may still be in flight when the value is gone. If you need to observe the unsubscription completing, call Client::unsubscribe instead and keep reading until SubscriptionEvent::Unsubscribed.

Backpressure: bounded, and nothing is dropped

The stream is fed by a bounded channel whose capacity is ConnectionOptions::with_update_capacity — 1024 events by default. When it fills, the client blocks rather than discarding anything, and that backpressure propagates through the session down to the socket. Concretely, a consumer that stops polling this stream will, once the buffer fills, stall the whole client: other subscriptions and the session’s own liveness included.

That is a deliberate choice, and the alternatives are worse. Dropping updates locally would corrupt the notification count that makes recovery after a broken connection correct [docs/spec/02-session-lifecycle.md §5.2], and it would hide loss the protocol goes out of its way to report — TLCP has its own overflow notification precisely so that a client is told when data was discarded [docs/spec/04-notifications.md §3.7].

What a long stall actually does

“Stalls the client” is literal, and it has a consequence worth planning for. While the client is blocked on a full stream it is not reading from the socket either, so its liveness timers do not advance. If you stop consuming for longer than the keepalive interval the server negotiated — reported to you as Connected::keepalive, plus ConnectionOptions::with_keepalive_slack — then the moment you start reading again the client will conclude the connection went silent, tear it down, and recover [docs/spec/02-session-lifecycle.md §8.1]. You will see a SessionEvent::Disconnected carrying DisconnectReason::Stalled, followed by a reconnection.

Nothing is lost when that happens — recovery is what the notification count exists for — but it is real work, and it is avoidable. A consumer that may pause for seconds at a time should either buffer on its own side or, better, ask the server to send less.

If you cannot keep up, say so to the server, which is where the protocol puts that decision: cap the rate with Subscription::with_max_frequency, or bound what the server buffers with Subscription::with_buffer_size. The server will then merge or drop on its side, and tell you it did with a SubscriptionEvent::Overflow.

The one exception: shutdown

“Nothing is dropped” holds while the client is running. It does not survive an ordered shutdown, and it deliberately does not: Client::disconnect and dropping the Client are signalled out of band, every blocked delivery gives way to them, and whatever had not yet been delivered is discarded along with this stream.

Without that exception a consumer that walked away could make the client impossible to stop — no disconnect, no drop, and a task and a socket alive until the process ended. Nothing observable is lost by it: a caller still reading frees room and the delivery completes, and a caller that has asked to disconnect has said it wants no more. See docs/adr/0003-typed-event-stream-as-delivery-surface.md.

Implementations

impl Updates

pub const fn id(&self) -> SubscriptionId

The handle identifying this subscription.

Stable for the life of the stream, including across a session that was lost and replaced. Use it to correlate with SessionEvent::Resubscribed.

Trait Implementations

impl Debug for Updates

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

Formats the value using the given formatter.

impl Drop for Updates

fn drop(&mut self)

Unsubscribes.

Best effort by necessity: a Drop cannot await and cannot report a failure. The command channel is unbounded, so the send only fails when the client has already stopped — in which case the subscription is gone anyway.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Stream for Updates

type Item = SubscriptionEvent

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.