1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

/// Interface to be implemented to listen to `LightstreamerClient.sendMessage()` events reporting
/// a message processing outcome. Events for these listeners are dispatched by a different
/// thread than the one that generates them. All the notifications for a single `LightstreamerClient`,
/// including notifications to `ClientListener`, `SubscriptionListener` and `ClientMessageListener`
/// will be dispatched by the same thread. Only one event per message is fired on this listener.
pub trait ClientMessageListener {
    /// Event handler that is called by Lightstreamer when any notifications of the processing
    /// outcome of the related message haven't been received yet and can no longer be received.
    /// Typically, this happens after the session has been closed. In this case, the client has
    /// no way of knowing the processing outcome and any outcome is possible.
    ///
    /// # Parameters
    ///
    /// * `msg`: the message to which this notification is related.
    /// * `sent_on_network`: `true` if the message was sent on the network, `false` otherwise.
    ///   Even if the flag is `true`, it is not possible to infer whether the message actually
    ///   reached the Lightstreamer Server or not.
    fn on_abort(&self, msg: &str, sent_on_network: bool) {
        // Implementation for on_abort
    }

    /// Event handler that is called by Lightstreamer when the related message has been processed
    /// by the Server but the expected processing outcome could not be achieved for any reason.
    ///
    /// # Parameters
    ///
    /// * `msg`: the message to which this notification is related.
    /// * `code`: the error code sent by the Server. It can be one of the following:
    ///   - `<= 0`: the Metadata Adapter has refused the message; the code value is dependent
    ///     on the specific Metadata Adapter implementation.
    /// * `error`: the description of the error sent by the Server.
    fn on_deny(&self, msg: &str, code: i32, error: &str) {
        // Implementation for on_deny
    }

    /// Event handler that is called by Lightstreamer to notify that the related message has
    /// been discarded by the Server. This means that the message has not reached the Metadata
    /// Adapter and the message next in the sequence is considered enabled for processing.
    ///
    /// # Parameters
    ///
    /// * `msg`: the message to which this notification is related.
    fn on_discarded(&self, msg: &str) {
        // Implementation for on_discarded
    }

    /// Event handler that is called by Lightstreamer when the related message has been processed
    /// by the Server but the processing has failed for any reason. The level of completion of
    /// the processing by the Metadata Adapter cannot be determined.
    ///
    /// # Parameters
    ///
    /// * `msg`: the message to which this notification is related.
    fn on_error(&self, msg: &str) {
        // Implementation for on_error
    }

    /// Event handler that is called by Lightstreamer when the related message has been processed
    /// by the Server with success.
    ///
    /// # Parameters
    ///
    /// * `msg`: the message to which this notification is related.
    /// * `response`: the response from the Metadata Adapter. If not supplied (i.e. supplied as `None`),
    ///   an empty message is received here.
    fn on_processed(&self, msg: &str, response: Option<&str>) {
        // Implementation for on_processed
    }
}