[client&server] Add "try" methods

2 files changed, 104 insertions, 2 deletions

diff --git a/src/client.rs b/src/client.rs
index 39c12db..6f97e55 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -151,6 +151,17 @@ impl Connection {
         }
     }
 
+    /// Same as [Connection::receive_message] but will log the error instead of returning it
+    pub fn try_receive_message<T: serde::de::DeserializeOwned>(&mut self) -> Option<T> {
+        match self.receive_message() {
+            Ok(message) => message,
+            Err(err) => {
+                error!("try_receive_message: {}", err);
+                None
+            }
+        }
+    }
+
     pub fn send_message<T: serde::Serialize>(&self, message: T) -> Result<(), QuinnetError> {
         match bincode::serialize(&message) {
             Ok(payload) => self.send_payload(payload),
@@ -158,6 +169,14 @@ impl Connection {
         }
     }
 
+    /// Same as [Connection::send_message] but will log the error instead of returning it
+    pub fn try_send_message<T: serde::Serialize>(&self, message: T) {
+        match self.send_message(message) {
+            Ok(_) => {}
+            Err(err) => error!("try_send_message: {}", err),
+        }
+    }
+
     pub fn send_payload<T: Into<Bytes>>(&self, payload: T) -> Result<(), QuinnetError> {
         match self.sender.try_send(payload.into()) {
             Ok(_) => Ok(()),
@@ -168,6 +187,14 @@ impl Connection {
         }
     }
 
+    /// Same as [Connection::send_payload] but will log the error instead of returning it
+    pub fn try_send_payload<T: Into<Bytes>>(&self, payload: T) {
+        match self.send_payload(payload) {
+            Ok(_) => {}
+            Err(err) => error!("try_send_payload: {}", err),
+        }
+    }
+
     pub fn receive_payload(&mut self) -> Result<Option<Bytes>, QuinnetError> {
         match self.receiver.try_recv() {
             Ok(msg_payload) => Ok(Some(msg_payload)),
@@ -178,8 +205,15 @@ impl Connection {
         }
     }
 
-    pub fn is_connected(&self) -> bool {
-        return self.state == ConnectionState::Connected;
+    /// Same as [Connection::receive_payload] but will log the error instead of returning it
+    pub fn try_receive_payload(&mut self) -> Option<Bytes> {
+        match self.receive_payload() {
+            Ok(payload) => payload,
+            Err(err) => {
+                error!("try_receive_payload: {}", err);
+                None
+            }
+        }
     }
 
     /// Disconnect from the server on this connection. This does not send any message to the server, and simply closes all the connection's tasks locally.
@@ -192,6 +226,10 @@ impl Connection {
         self.state = ConnectionState::Disconnected;
         Ok(())
     }
+
+    pub fn is_connected(&self) -> bool {
+        return self.state == ConnectionState::Connected;
+    }
 }
 
 #[derive(Resource)]
@@ -310,6 +348,11 @@ impl Client {
         self.default_connection_id = Some(connection_id);
     }
 
+    /// Get the default Connection Id
+    pub fn get_default_connection(&self) -> Option<ConnectionId> {
+        self.default_connection_id
+    }
+
     /// Close a specific connection. This will call disconnect on the connection and remove it from the client. This may fail if the [Connection] fails to disconnect or if no [Connection] if found for connection_id
     pub fn close_connection(&mut self, connection_id: ConnectionId) -> Result<(), QuinnetError> {
         match self.connections.remove(&connection_id) {
diff --git a/src/server.rs b/src/server.rs
index 62bac3d..b08a8d0 100644
--- a/src/server.rs
+++ b/src/server.rs
@@ -126,6 +126,16 @@ impl Endpoint {
         }
     }
 
+    pub fn try_receive_message<T: serde::de::DeserializeOwned>(&mut self) -> Option<(T, ClientId)> {
+        match self.receive_message() {
+            Ok(message) => message,
+            Err(err) => {
+                error!("try_receive_message: {}", err);
+                None
+            }
+        }
+    }
+
     pub fn send_message<T: serde::Serialize>(
         &mut self,
         client_id: ClientId,
@@ -137,6 +147,13 @@ impl Endpoint {
         }
     }
 
+    pub fn try_send_message<T: serde::Serialize>(&mut self, client_id: ClientId, message: T) {
+        match self.send_message(client_id, message) {
+            Ok(_) => {}
+            Err(err) => error!("try_send_message: {}", err),
+        }
+    }
+
     pub fn send_group_message<'a, I: Iterator<Item = &'a ClientId>, T: serde::Serialize>(
         &self,
         client_ids: I,
@@ -153,6 +170,17 @@ impl Endpoint {
         }
     }
 
+    pub fn try_send_group_message<'a, I: Iterator<Item = &'a ClientId>, T: serde::Serialize>(
+        &self,
+        client_ids: I,
+        message: T,
+    ) {
+        match self.send_group_message(client_ids, message) {
+            Ok(_) => {}
+            Err(err) => error!("try_send_group_message: {}", err),
+        }
+    }
+
     pub fn broadcast_message<T: serde::Serialize>(&self, message: T) -> Result<(), QuinnetError> {
         match bincode::serialize(&message) {
             Ok(payload) => Ok(self.broadcast_payload(payload)?),
@@ -160,6 +188,13 @@ impl Endpoint {
         }
     }
 
+    pub fn try_broadcast_message<T: serde::Serialize>(&self, message: T) {
+        match self.broadcast_message(message) {
+            Ok(_) => {}
+            Err(err) => error!("try_broadcast_message: {}", err),
+        }
+    }
+
     pub fn broadcast_payload<T: Into<Bytes> + Clone>(
         &self,
         payload: T,
@@ -178,6 +213,13 @@ impl Endpoint {
         Ok(())
     }
 
+    pub fn try_broadcast_payload<T: Into<Bytes> + Clone>(&self, payload: T) {
+        match self.broadcast_payload(payload) {
+            Ok(_) => {}
+            Err(err) => error!("try_broadcast_payload: {}", err),
+        }
+    }
+
     pub fn send_payload<T: Into<Bytes>>(
         &self,
         client_id: ClientId,
@@ -196,6 +238,13 @@ impl Endpoint {
         }
     }
 
+    pub fn try_send_payload<T: Into<Bytes>>(&self, client_id: ClientId, payload: T) {
+        match self.send_payload(client_id, payload) {
+            Ok(_) => {}
+            Err(err) => error!("try_send_payload: {}", err),
+        }
+    }
+
     pub fn receive_payload(&mut self) -> Result<Option<ClientPayload>, QuinnetError> {
         match self.payloads_receiver.try_recv() {
             Ok(msg) => Ok(Some(msg)),
@@ -206,6 +255,16 @@ impl Endpoint {
         }
     }
 
+    pub fn try_receive_payload(&mut self) -> Option<ClientPayload> {
+        match self.receive_payload() {
+            Ok(payload) => payload,
+            Err(err) => {
+                error!("try_receive_payload: {}", err);
+                None
+            }
+        }
+    }
+
     pub fn disconnect_client(&mut self, client_id: ClientId) -> Result<(), QuinnetError> {
         match self.clients.remove(&client_id) {
             Some(client_connection) => match client_connection.close_sender.send(()) {