Implement shared custom data

socketio/src/asynchronous/client/builder.rs

@@ -6,6 +6,7 @@ use rust_engineio::{
     header::{HeaderMap, HeaderValue},
 };
 use std::collections::HashMap;
+use std::sync::Arc;
 use url::Url;
 
 use crate::{error::Result, Event, Payload, TransportType};
@@ -38,6 +39,7 @@ pub struct ClientBuilder {
     pub(crate) max_reconnect_attempts: Option<u8>,
     pub(crate) reconnect_delay_min: u64,
     pub(crate) reconnect_delay_max: u64,
+    pub(crate) data: Option<Arc<dyn std::any::Any + Send + Sync>>,
 }
 
 impl ClientBuilder {
@@ -97,9 +99,15 @@ impl ClientBuilder {
             max_reconnect_attempts: None,
             reconnect_delay_min: 1000,
             reconnect_delay_max: 5000,
+            data: None,
         }
     }
 
+    pub fn data<D: std::any::Any + Send + Sync>(mut self, data: Arc<D>) -> Self {
+        self.data = Some(data);
+        self
+    }
+
     /// Sets the target namespace of the client. The namespace should start
     /// with a leading `/`. Valid examples are e.g. `/admin`, `/foo`.
     /// If the String provided doesn't start with a leading `/`, it is

socketio/src/asynchronous/client/client.rs

@@ -74,6 +74,7 @@ pub struct Client {
     auth: Option<serde_json::Value>,
     builder: Arc<RwLock<ClientBuilder>>,
     disconnect_reason: Arc<RwLock<DisconnectReason>>,
+    data: Arc<dyn std::any::Any + Send + Sync>,
 }
 
 impl Client {
@@ -87,11 +88,25 @@ impl Client {
             nsp: builder.namespace.to_owned(),
             outstanding_acks: Arc::new(RwLock::new(Vec::new())),
             auth: builder.auth.clone(),
+            data: builder.data.clone().unwrap_or(Arc::new(())),
             builder: Arc::new(RwLock::new(builder)),
             disconnect_reason: Arc::new(RwLock::new(DisconnectReason::default())),
         })
     }
 
+    /// Fetches data given by [`ClientBuilder::data`]
+    pub fn data<D: Send + Sync + 'static>(&self) -> Arc<D> {
+        self.try_data()
+            .expect("Client::data does not match ClientBuilder::data")
+    }
+
+    /// Attempts to fetch data given by [`ClientBuilder::data`]
+    ///
+    /// None is returned if data was not given or data does not match [`ClientBuilder::data`]
+    pub fn try_data<D: Send + Sync + 'static>(&self) -> Option<Arc<D>> {
+        Arc::clone(&self.data).downcast().ok()
+    }
+
     /// Connects the client to a server. Afterwards the `emit_*` methods can be
     /// called to interact with the server.
     pub(crate) async fn connect(&self) -> Result<()> {

socketio/src/client/builder.rs

@@ -41,6 +41,7 @@ pub struct ClientBuilder {
     opening_headers: Option<HeaderMap>,
     transport_type: TransportType,
     auth: Option<serde_json::Value>,
+    data: Option<Arc<dyn std::any::Any + Send + Sync>>,
     pub(crate) reconnect: bool,
     pub(crate) reconnect_on_disconnect: bool,
     // None reconnect attempts represent infinity.
@@ -98,9 +99,15 @@ impl ClientBuilder {
             max_reconnect_attempts: None,
             reconnect_delay_min: 1000,
             reconnect_delay_max: 5000,
+            data: None,
         }
     }
 
+    pub fn data<D: std::any::Any + Send + Sync>(mut self, data: Arc<D>) -> Self {
+        self.data = Some(data);
+        self
+    }
+
     /// Sets the target namespace of the client. The namespace should start
     /// with a leading `/`. Valid examples are e.g. `/admin`, `/foo`.
     pub fn namespace<T: Into<String>>(mut self, namespace: T) -> Self {
@@ -365,6 +372,7 @@ impl ClientBuilder {
             self.on,
             self.on_any,
             self.auth,
+            self.data.unwrap_or(Arc::new(())),
         )?;
         socket.connect()?;
 

socketio/src/client/raw_client.rs

@@ -14,6 +14,7 @@ use std::time::Duration;
 use std::time::Instant;
 
 use crate::socket::Socket as InnerSocket;
+use crate::asynchronous::ClientBuilder;
 
 /// Represents an `Ack` as given back to the caller. Holds the internal `id` as
 /// well as the current ack'ed state. Holds data which will be accessible as
@@ -41,6 +42,7 @@ pub struct RawClient {
     nsp: String,
     // Data send in the opening packet (commonly used as for auth)
     auth: Option<Value>,
+    data: Arc<dyn std::any::Any + Send + Sync>,
 }
 
 impl RawClient {
@@ -54,6 +56,7 @@ impl RawClient {
         on: Arc<Mutex<HashMap<Event, Callback<SocketCallback>>>>,
         on_any: Arc<Mutex<Option<Callback<SocketAnyCallback>>>>,
         auth: Option<Value>,
+        data: Arc<dyn std::any::Any + Send + Sync>,
     ) -> Result<Self> {
         Ok(RawClient {
             socket,
@@ -62,9 +65,23 @@ impl RawClient {
             on_any,
             outstanding_acks: Arc::new(Mutex::new(Vec::new())),
             auth,
+            data,
         })
     }
 
+    /// Fetches data given by [`ClientBuilder::data`]
+    pub fn data<D: Send + Sync + 'static>(&self) -> Arc<D> {
+        self.try_data()
+            .expect("RawClient::data does not match ClientBuilder::data")
+    }
+
+    /// Attempts to fetch data given by [`ClientBuilder::data`]
+    ///
+    /// None is returned if data was not given or data does not match [`ClientBuilder::data`]
+    pub fn try_data<D: Send + Sync + 'static>(&self) -> Option<Arc<D>> {
+        Arc::clone(&self.data).downcast().ok()
+    }
+
     /// Connects the client to a server. Afterwards the `emit_*` methods can be
     /// called to interact with the server. Attention: it's not allowed to add a
     /// callback after a call to this method.