Struct ChannelSubscriptionListener 

pub struct ChannelSubscriptionListener { /* private fields */ }

A subscription listener that forwards item updates to a tokio mpsc channel.

This listener allows decoupling the reception of updates from their processing, enabling asynchronous consumption of updates by other tasks or components.

Examples

use lightstreamer_rs::subscription::{ChannelSubscriptionListener, ItemUpdate};
use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::unbounded_channel();
let listener = ChannelSubscriptionListener::new(tx);

// Add listener to subscription
subscription.add_listener(Box::new(listener));

// Process updates in a separate task
tokio::spawn(async move {
    while let Some(update) = rx.recv().await {
        println!("Received update: {:?}", update);
    }
});

Implementations

impl ChannelSubscriptionListener

pub fn new(sender: UnboundedSender<ItemUpdate>) -> Self

Creates a new ChannelSubscriptionListener with the provided sender.

Arguments

• sender - An unbounded mpsc sender for forwarding ItemUpdate events

Returns

A new instance of ChannelSubscriptionListener

pub fn create_channel() -> (Self, UnboundedReceiver<ItemUpdate>)

Creates a new channel pair and returns both the listener and receiver.

This is a convenience method that creates both the channel and the listener in a single call.

Returns

A tuple containing:

• The ChannelSubscriptionListener instance
• The receiver end of the channel for consuming updates

Examples

use lightstreamer_rs::subscription::ChannelSubscriptionListener;

let (listener, mut rx) = ChannelSubscriptionListener::create_channel();
subscription.add_listener(Box::new(listener));

tokio::spawn(async move {
    while let Some(update) = rx.recv().await {
        // Process update
    }
});

Trait Implementations

impl SubscriptionListener for ChannelSubscriptionListener

fn on_item_update(&self, update: &ItemUpdate)

Event handler that is called by Lightstreamer each time an update pertaining to an item in the Subscription has been received from the Server.

fn on_subscription(&mut self)

Event handler that is called by Lightstreamer to notify that a Subscription has been successfully subscribed to through the Server. This can happen multiple times in the life of a Subscription instance, in case the Subscription is performed multiple times through LightstreamerClient::unsubscribe() and LightstreamerClient::subscribe(). This can also happen multiple times in case of automatic recovery after a connection restart.

fn on_unsubscription(&mut self)

Event handler that is called by Lightstreamer to notify that a Subscription has been successfully unsubscribed from. This can happen multiple times in the life of a Subscription instance, in case the Subscription is performed multiple times through LightstreamerClient::unsubscribe() and LightstreamerClient::subscribe(). This can also happen multiple times in case of automatic recovery after a connection restart.

fn on_clear_snapshot(&mut self, _item_name: Option<&str>, _item_pos: usize)

Event handler that is called by Lightstreamer each time a request to clear the snapshot pertaining to an item in the Subscription has been received from the Server. More precisely, this kind of request can occur in two cases:

fn on_command_second_level_item_lost_updates( &mut self, _lost_updates: u32, _key: &str, )

Event handler that is called by Lightstreamer to notify that, due to internal resource limitations, Lightstreamer Server dropped one or more updates for an item that was subscribed to as a second-level subscription. Such notifications are sent only if the Subscription was configured in unfiltered mode (second-level items are always in “MERGE” mode and inherit the frequency configuration from the first-level Subscription).

fn on_command_second_level_subscription_error( &mut self, _code: i32, _message: Option<&str>, _key: &str, )

Event handler that is called when the Server notifies an error on a second-level subscription.

fn on_end_of_snapshot(&mut self, _item_name: Option<&str>, _item_pos: usize)

Event handler that is called by Lightstreamer to notify that all snapshot events for an item in the Subscription have been received, so that real time events are now going to be received. The received snapshot could be empty. Such notifications are sent only if the items are delivered in DISTINCT or COMMAND subscription mode and snapshot information was indeed requested for the items. By implementing this method it is possible to perform actions which require that all the initial values have been received.

fn on_item_lost_updates( &mut self, _item_name: Option<&str>, _item_pos: usize, _lost_updates: u32, )

Event handler that is called by Lightstreamer to notify that, due to internal resource limitations, Lightstreamer Server dropped one or more updates for an item in the Subscription. Such notifications are sent only if the items are delivered in an unfiltered mode; this occurs if the subscription mode is:

fn on_listen_end(&mut self)

Event handler that receives a notification when the SubscriptionListener instance is removed from a Subscription through Subscription::remove_listener(). This is the last event to be fired on the listener.

fn on_listen_start(&mut self)

Event handler that receives a notification when the SubscriptionListener instance is added to a Subscription through Subscription::add_listener(). This is the first event to be fired on the listener.

fn on_real_max_frequency(&mut self, _frequency: Option<f64>)

Event handler that is called by Lightstreamer to notify the client with the real maximum update frequency of the Subscription. It is called immediately after the Subscription is established and in response to a requested change (see Subscription::set_requested_max_frequency()). Since the frequency limit is applied on an item basis and a Subscription can involve multiple items, this is actually the maximum frequency among all items. For Subscriptions with two-level behavior (see Subscription::set_command_second_level_fields() and Subscription::set_command_second_level_field_schema()), the reported frequency limit applies to both first-level and second-level items.

fn on_subscription_error(&mut self, _code: i32, _message: Option<&str>)

Event handler that is called when the Server notifies an error on a Subscription. By implementing this method it is possible to perform recovery actions.