teamtalk 6.0.0

TeamTalk SDK for Rust
Documentation 
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
70
71
72
73

use super::*;

pub trait EventSource {
    /// Polls for the next event.
    fn poll(&mut self, timeout_ms: i32) -> Option<(Event, Message)>;
    /// Returns the underlying client if available.
    fn client(&self) -> Option<&Client>;
}

impl EventSource for Client {
    fn poll(&mut self, timeout_ms: i32) -> Option<(Event, Message)> {
        Client::poll(self, timeout_ms)
    }

    fn client(&self) -> Option<&Client> {
        Some(self)
    }
}

impl EventSource for &Client {
    fn poll(&mut self, timeout_ms: i32) -> Option<(Event, Message)> {
        (*self).poll(timeout_ms)
    }

    fn client(&self) -> Option<&Client> {
        Some(*self)
    }
}

pub(super) type HandlerFn = Box<dyn for<'a> FnMut(EventContext<'a>) -> DispatchFlow + Send>;

pub(super) struct HandlerEntry {
    pub(super) event: Option<Event>,
    pub(super) handler: HandlerFn,
}

impl HandlerEntry {
    pub(super) fn matches(&self, event: &Event) -> bool {
        match &self.event {
            Some(e) => mem::discriminant(e) == mem::discriminant(event),
            None => true,
        }
    }
}

pub(super) struct ReconnectState {
    params: ConnectParamsOwned,
    handler: ReconnectHandler,
    extra_events: Vec<Event>,
}

impl ReconnectState {
    pub(super) fn new(settings: ReconnectSettings) -> Self {
        Self {
            handler: ReconnectHandler::new(settings.config),
            params: settings.params,
            extra_events: settings.extra_events,
        }
    }

    pub(super) fn on_event(&mut self, client: Option<&Client>, event: &Event) {
        if matches!(event, Event::ConnectSuccess) {
            self.handler.mark_connected();
        }
        if event.is_reconnect_needed_with(&self.extra_events) {
            self.handler.mark_disconnected();
            if let Some(client) = client {
                let params = self.params.as_params();
                client.handle_reconnect(&params, &mut self.handler);
            }
        }
    }
}