Add prefix "Default" To Gateway, -Handler and HeartbeatHandler

src/api/auth/mod.rs

@@ -6,7 +6,7 @@ pub use register::*;
 use crate::gateway::{GatewayCapable, GatewayHandleCapable};
 use crate::{
     errors::ChorusResult,
-    gateway::Gateway,
+    gateway::DefaultGateway,
     instance::{ChorusUser, Instance},
     types::{GatewayIdentifyPayload, User},
 };
@@ -26,7 +26,9 @@ impl Instance {
             .await
             .unwrap();
         let mut identify = GatewayIdentifyPayload::common();
-        let gateway = Gateway::get_handle(self.urls.wss.clone()).await.unwrap();
+        let gateway = DefaultGateway::get_handle(self.urls.wss.clone())
+            .await
+            .unwrap();
         identify.token = token.clone();
         gateway.send_identify(identify).await;
         let user = ChorusUser::new(

src/gateway/gateway.rs

@@ -301,9 +301,9 @@ where
 }
 
 #[derive(Debug)]
-pub struct Gateway {
+pub struct DefaultGateway {
     events: Arc<Mutex<Events>>,
-    heartbeat_handler: HeartbeatHandler,
+    heartbeat_handler: DefaultHeartbeatHandler,
     websocket_send: Arc<
         Mutex<
             SplitSink<
@@ -323,16 +323,16 @@ impl
     GatewayCapable<
         WebSocketStream<MaybeTlsStream<TcpStream>>,
         WebSocketStream<MaybeTlsStream<TcpStream>>,
-        GatewayHandle,
+        DefaultGatewayHandle,
-        HeartbeatHandler,
+        DefaultHeartbeatHandler,
-    > for Gateway
+    > for DefaultGateway
 {
-    fn get_heartbeat_handler(&self) -> &HeartbeatHandler {
+    fn get_heartbeat_handler(&self) -> &DefaultHeartbeatHandler {
         &self.heartbeat_handler
     }
 
     #[allow(clippy::new_ret_no_self)]
-    async fn get_handle(websocket_url: String) -> Result<GatewayHandle, GatewayError> {
+    async fn get_handle(websocket_url: String) -> Result<DefaultGatewayHandle, GatewayError> {
         let mut roots = rustls::RootCertStore::empty();
         for cert in rustls_native_certs::load_native_certs().expect("could not load platform certs")
         {
@@ -389,9 +389,9 @@ impl
 
         let store = Arc::new(Mutex::new(HashMap::new()));
 
-        let mut gateway = Gateway {
+        let mut gateway = DefaultGateway {
             events: shared_events.clone(),
-            heartbeat_handler: HeartbeatHandler::new(
+            heartbeat_handler: DefaultHeartbeatHandler::new(
                 Duration::from_millis(gateway_hello.heartbeat_interval),
                 shared_websocket_send.clone(),
                 kill_send.subscribe(),
@@ -408,7 +408,7 @@ impl
             gateway.gateway_listen_task().await;
         });
 
-        Ok(GatewayHandle {
+        Ok(DefaultGatewayHandle {
             url: websocket_url.clone(),
             events: shared_events,
             websocket_send: shared_websocket_send.clone(),
@@ -442,7 +442,7 @@ impl
     }
 }
 
-impl Gateway {
+impl DefaultGateway {
     /// The main gateway listener task;
     ///
     /// Can only be stopped by closing the websocket, cannot be made to listen for kill

src/gateway/handle.rs

@@ -106,7 +106,7 @@ impl
     GatewayHandleCapable<
         WebSocketStream<MaybeTlsStream<TcpStream>>,
         WebSocketStream<MaybeTlsStream<TcpStream>>,
-    > for GatewayHandle
+    > for DefaultGatewayHandle
 {
     async fn send_json_event(&self, op_code: u8, to_send: serde_json::Value) {
         self.send_json_event(op_code, to_send).await
@@ -130,7 +130,7 @@ impl
 /// implemented types with the trait [`WebSocketEvent`]
 /// Using this handle you can also send Gateway Events directly.
 #[derive(Debug, Clone)]
-pub struct GatewayHandle {
+pub struct DefaultGatewayHandle {
     pub url: String,
     pub events: Arc<Mutex<Events>>,
     pub websocket_send: Arc<
@@ -146,7 +146,7 @@ pub struct GatewayHandle {
     pub(crate) store: GatewayStore,
 }
 
-impl GatewayHandle {
+impl DefaultGatewayHandle {
     async fn send_json_event(&self, op_code: u8, to_send: serde_json::Value) {
         let gateway_payload = types::GatewaySendPayload {
             op_code,

src/gateway/heartbeat.rs

@@ -19,7 +19,7 @@ pub trait HeartbeatHandlerCapable<S: Sink<Message>> {
 /// Handles sending heartbeats to the gateway in another thread
 #[allow(dead_code)] // FIXME: Remove this, once HeartbeatHandler is used
 #[derive(Debug)]
-pub struct HeartbeatHandler {
+pub struct DefaultHeartbeatHandler {
     /// How ofter heartbeats need to be sent at a minimum
     pub heartbeat_interval: Duration,
     /// The send channel for the heartbeat thread
@@ -28,7 +28,9 @@ pub struct HeartbeatHandler {
     handle: JoinHandle<()>,
 }
 
-impl HeartbeatHandlerCapable<WebSocketStream<MaybeTlsStream<TcpStream>>> for HeartbeatHandler {
+impl HeartbeatHandlerCapable<WebSocketStream<MaybeTlsStream<TcpStream>>>
+    for DefaultHeartbeatHandler
+{
     fn new(
         heartbeat_interval: Duration,
         websocket_tx: Arc<
@@ -40,12 +42,12 @@ impl HeartbeatHandlerCapable<WebSocketStream<MaybeTlsStream<TcpStream>>> for Hea
             >,
         >,
         kill_rc: tokio::sync::broadcast::Receiver<()>,
-    ) -> HeartbeatHandler {
+    ) -> DefaultHeartbeatHandler {
         let (send, receive) = tokio::sync::mpsc::channel(32);
         let kill_receive = kill_rc.resubscribe();
 
         let handle: JoinHandle<()> = task::spawn(async move {
-            HeartbeatHandler::heartbeat_task(
+            DefaultHeartbeatHandler::heartbeat_task(
                 websocket_tx,
                 heartbeat_interval,
                 receive,
@@ -70,7 +72,7 @@ impl HeartbeatHandlerCapable<WebSocketStream<MaybeTlsStream<TcpStream>>> for Hea
     }
 }
 
-impl HeartbeatHandler {
+impl DefaultHeartbeatHandler {
     /// The main heartbeat task;
     ///
     /// Can be killed by the kill broadcast;

src/lib.rs

@@ -20,8 +20,8 @@ compile_error!("feature \"rt\" and feature \"rt_multi_thread\" cannot be enabled
 pub type Gateway = WebsocketGateway;
 pub type GatewayHandle = WebsocketGatewayHandle;
 
-use gateway::Gateway as WebsocketGateway;
+use gateway::DefaultGateway as WebsocketGateway;
-use gateway::GatewayHandle as WebsocketGatewayHandle;
+use gateway::DefaultGatewayHandle as WebsocketGatewayHandle;
 use url::{ParseError, Url};
 
 #[cfg(feature = "client")]

tests/common/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::{Arc, RwLock};
 
-use chorus::gateway::{Gateway, GatewayCapable};
+use chorus::gateway::{DefaultGateway, GatewayCapable};
 use chorus::{
     instance::{ChorusUser, Instance},
     types::{
@@ -43,7 +43,7 @@ impl TestBundle {
             limits: self.user.limits.clone(),
             settings: self.user.settings.clone(),
             object: self.user.object.clone(),
-            gateway: Gateway::get_handle(self.instance.urls.wss.clone())
+            gateway: DefaultGateway::get_handle(self.instance.urls.wss.clone())
                 .await
                 .unwrap(),
         }

tests/gateway.rs

@@ -10,7 +10,9 @@ use chorus::types::{self, ChannelModifySchema, RoleCreateModifySchema, RoleObjec
 async fn test_gateway_establish() {
     let bundle = common::setup().await;
 
-    Gateway::get_handle(bundle.urls.wss.clone()).await.unwrap();
+    DefaultGateway::get_handle(bundle.urls.wss.clone())
+        .await
+        .unwrap();
     common::teardown(bundle).await
 }
 
@@ -19,7 +21,9 @@ async fn test_gateway_establish() {
 async fn test_gateway_authenticate() {
     let bundle = common::setup().await;
 
-    let gateway = Gateway::get_handle(bundle.urls.wss.clone()).await.unwrap();
+    let gateway = DefaultGateway::get_handle(bundle.urls.wss.clone())
+        .await
+        .unwrap();
 
     let mut identify = types::GatewayIdentifyPayload::common();
     identify.token = bundle.user.token.clone();