naia-client 0.24.0

Provides a cross-platform client that can send/receive messages to/from a server, and has a pool of in-scope entities/components that is synced with the server.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use naia_shared::SocketConfig;

use naia_client_socket::{
    IdentityReceiver, IdentityReceiverResult as SocketIdentityReceiverResult, PacketReceiver, PacketSender, ServerAddr,
    Socket as ClientSocket,
};

use super::{
    IdentityReceiver as TransportIdentityReceiver, PacketReceiver as TransportReceiver,
    PacketSender as TransportSender, RecvError, SendError, ServerAddr as TransportAddr,
    Socket as TransportSocket, IdentityReceiverResult,
};

pub struct Socket {
    server_session_url: String,
    config: SocketConfig,
}

impl Socket {
    pub fn new(server_session_url: &str, config: &SocketConfig) -> Self {
        return Self {
            server_session_url: server_session_url.to_string(),
            config: config.clone(),
        };
    }
}

impl TransportSender for Box<dyn PacketSender> {
    /// Sends a packet from the Client Socket
    fn send(&self, payload: &[u8]) -> Result<(), SendError> {
        self.as_ref().send(payload).map_err(|_| SendError)
    }
    /// Get the Server's Socket address
    fn server_addr(&self) -> TransportAddr {
        match self.as_ref().server_addr() {
            ServerAddr::Found(addr) => TransportAddr::Found(addr),
            ServerAddr::Finding => TransportAddr::Finding,
        }
    }
}

impl TransportReceiver for Box<dyn PacketReceiver> {
    /// Receives a packet from the Client Socket
    fn receive(&mut self) -> Result<Option<&[u8]>, RecvError> {
        self.as_mut().receive().map_err(|_| RecvError)
    }
    /// Get the Server's Socket address
    fn server_addr(&self) -> TransportAddr {
        match self.as_ref().server_addr() {
            ServerAddr::Found(addr) => TransportAddr::Found(addr),
            ServerAddr::Finding => TransportAddr::Finding,
        }
    }
}

impl TransportIdentityReceiver for Box<dyn IdentityReceiver> {
    /// Receives an IdentityToken from the Client Socket
    fn receive(&mut self) -> IdentityReceiverResult {
        match self.as_mut().receive() {
            SocketIdentityReceiverResult::Waiting => IdentityReceiverResult::Waiting,
            SocketIdentityReceiverResult::Success(token) => IdentityReceiverResult::Success(token),
            SocketIdentityReceiverResult::ErrorResponseCode(code) => IdentityReceiverResult::ErrorResponseCode(code),
        }
    }
}

impl Into<Box<dyn TransportSocket>> for Socket {
    fn into(self) -> Box<dyn TransportSocket> {
        Box::new(self)
    }
}

impl TransportSocket for Socket {
    fn connect(
        self: Box<Self>,
    ) -> (
        Box<dyn TransportIdentityReceiver>,
        Box<dyn TransportSender>,
        Box<dyn TransportReceiver>,
    ) {
        let (id_receiver, inner_sender, inner_receiver) =
            ClientSocket::connect(&self.server_session_url, &self.config);
        return (
            Box::new(id_receiver),
            Box::new(inner_sender),
            Box::new(inner_receiver),
        );
    }
    fn connect_with_auth(
        self: Box<Self>,
        auth_bytes: Vec<u8>,
    ) -> (
        Box<dyn TransportIdentityReceiver>,
        Box<dyn TransportSender>,
        Box<dyn TransportReceiver>,
    ) {
        let (id_receiver, inner_sender, inner_receiver) =
            ClientSocket::connect_with_auth(&self.server_session_url, &self.config, auth_bytes);
        return (
            Box::new(id_receiver),
            Box::new(inner_sender),
            Box::new(inner_receiver),
        );
    }
    fn connect_with_auth_headers(
        self: Box<Self>,
        auth_headers: Vec<(String, String)>,
    ) -> (
        Box<dyn TransportIdentityReceiver>,
        Box<dyn TransportSender>,
        Box<dyn TransportReceiver>,
    ) {
        let (id_receiver, inner_sender, inner_receiver) = ClientSocket::connect_with_auth_headers(
            &self.server_session_url,
            &self.config,
            auth_headers,
        );
        return (
            Box::new(id_receiver),
            Box::new(inner_sender),
            Box::new(inner_receiver),
        );
    }
    fn connect_with_auth_and_headers(
        self: Box<Self>,
        auth_bytes: Vec<u8>,
        auth_headers: Vec<(String, String)>,
    ) -> (
        Box<dyn TransportIdentityReceiver>,
        Box<dyn TransportSender>,
        Box<dyn TransportReceiver>,
    ) {
        let (id_receiver, inner_sender, inner_receiver) =
            ClientSocket::connect_with_auth_and_headers(
                &self.server_session_url,
                &self.config,
                auth_bytes,
                auth_headers,
            );
        return (
            Box::new(id_receiver),
            Box::new(inner_sender),
            Box::new(inner_receiver),
        );
    }
}