Simplify ShardManager creation

Instead of creating different `new` functions for every bridged feature
combination, accept a struct of options. Structs can have conditional
fields, unlike functions which can not have conditional arguments.

3 files changed, 54 insertions, 119 deletions

diff --git a/src/client/bridge/gateway/mod.rs b/src/client/bridge/gateway/mod.rs
index 23d2864..2907877 100644
--- a/src/client/bridge/gateway/mod.rs
+++ b/src/client/bridge/gateway/mod.rs
@@ -56,7 +56,7 @@ mod shard_queuer;
 mod shard_runner;
 mod shard_runner_message;
 
-pub use self::shard_manager::ShardManager;
+pub use self::shard_manager::{ShardManager, ShardManagerOptions};
 pub use self::shard_manager_monitor::ShardManagerMonitor;
 pub use self::shard_messenger::ShardMessenger;
 pub use self::shard_queuer::ShardQueuer;
diff --git a/src/client/bridge/gateway/shard_manager.rs b/src/client/bridge/gateway/shard_manager.rs
index 928b477..1ef981f 100644
--- a/src/client/bridge/gateway/shard_manager.rs
+++ b/src/client/bridge/gateway/shard_manager.rs
@@ -111,69 +111,8 @@ pub struct ShardManager {
 impl ShardManager {
     /// Creates a new shard manager, returning both the manager and a monitor
     /// for usage in a separate thread.
-    #[cfg(feature = "framework")]
-    #[cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
-    pub fn new<H>(
-        shard_index: u64,
-        shard_init: u64,
-        shard_total: u64,
-        ws_url: &Arc<Mutex<String>>,
-        token: &Arc<Mutex<String>>,
-        data: &Arc<Mutex<ShareMap>>,
-        event_handler: &Arc<H>,
-        framework: &Arc<Mutex<Option<Box<Framework + Send>>>>,
-        threadpool: ThreadPool,
-    ) -> (Arc<Mutex<Self>>, ShardManagerMonitor) where H: EventHandler + Send + Sync + 'static {
-        let (thread_tx, thread_rx) = mpsc::channel();
-        let (shard_queue_tx, shard_queue_rx) = mpsc::channel();
-
-        let runners = Arc::new(Mutex::new(HashMap::new()));
-
-        let mut shard_queuer = ShardQueuer {
-            data: Arc::clone(data),
-            event_handler: Arc::clone(event_handler),
-            framework: Arc::clone(framework),
-            last_start: None,
-            manager_tx: thread_tx.clone(),
-            queue: VecDeque::new(),
-            runners: Arc::clone(&runners),
-            rx: shard_queue_rx,
-            token: Arc::clone(token),
-            ws_url: Arc::clone(ws_url),
-            threadpool,
-        };
-
-        thread::spawn(move || {
-            shard_queuer.run();
-        });
-
-        let manager = Arc::new(Mutex::new(Self {
-            monitor_tx: thread_tx,
-            shard_queuer: shard_queue_tx,
-            runners,
-            shard_index,
-            shard_init,
-            shard_total,
-        }));
-
-        (Arc::clone(&manager), ShardManagerMonitor {
-            rx: thread_rx,
-            manager,
-        })
-    }
-
-    /// Creates a new shard manager, returning both the manager and a monitor
-    /// for usage in a separate thread.
-    #[cfg(not(feature = "framework"))]
-    pub fn new<H>(
-        shard_index: u64,
-        shard_init: u64,
-        shard_total: u64,
-        ws_url: Arc<Mutex<String>>,
-        token: Arc<Mutex<String>>,
-        data: Arc<Mutex<ShareMap>>,
-        event_handler: Arc<H>,
-        threadpool: ThreadPool,
+    pub fn new<'a, H>(
+        opt: ShardManagerOptions<'a, H>,
     ) -> (Arc<Mutex<Self>>, ShardManagerMonitor) where H: EventHandler + Send + Sync + 'static {
         let (thread_tx, thread_rx) = mpsc::channel();
         let (shard_queue_tx, shard_queue_rx) = mpsc::channel();
@@ -181,16 +120,18 @@ impl ShardManager {
         let runners = Arc::new(Mutex::new(HashMap::new()));
 
         let mut shard_queuer = ShardQueuer {
-            data: Arc::clone(&data),
-            event_handler: Arc::clone(&event_handler),
+            data: Arc::clone(opt.data),
+            event_handler: Arc::clone(opt.event_handler),
+            #[cfg(feature = "framework")]
+            framework: Arc::clone(opt.framework),
             last_start: None,
             manager_tx: thread_tx.clone(),
             queue: VecDeque::new(),
             runners: Arc::clone(&runners),
             rx: shard_queue_rx,
-            token: Arc::clone(&token),
-            ws_url: Arc::clone(&ws_url),
-            threadpool,
+            threadpool: opt.threadpool,
+            token: Arc::clone(opt.token),
+            ws_url: Arc::clone(opt.ws_url),
         };
 
         thread::spawn(move || {
@@ -199,11 +140,11 @@ impl ShardManager {
 
         let manager = Arc::new(Mutex::new(Self {
             monitor_tx: thread_tx,
+            shard_index: opt.shard_index,
+            shard_init: opt.shard_init,
             shard_queuer: shard_queue_tx,
+            shard_total: opt.shard_total,
             runners,
-            shard_index,
-            shard_init,
-            shard_total,
         }));
 
         (Arc::clone(&manager), ShardManagerMonitor {
@@ -386,3 +327,16 @@ impl Drop for ShardManager {
         }
     }
 }
+
+pub struct ShardManagerOptions<'a, H: EventHandler + Send + Sync + 'static> {
+    pub data: &'a Arc<Mutex<ShareMap>>,
+    pub event_handler: &'a Arc<H>,
+    #[cfg(feature = "framework")]
+    pub framework: &'a Arc<Mutex<Option<Box<Framework + Send>>>>,
+    pub shard_index: u64,
+    pub shard_init: u64,
+    pub shard_total: u64,
+    pub threadpool: ThreadPool,
+    pub token: &'a Arc<Mutex<String>>,
+    pub ws_url: &'a Arc<Mutex<String>>,
+}
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 064e27f..2e01104 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -41,7 +41,7 @@ use http;
 use internal::prelude::*;
 use model::id::UserId;
 use parking_lot::Mutex;
-use self::bridge::gateway::{ShardManager, ShardManagerMonitor};
+use self::bridge::gateway::{ShardManager, ShardManagerMonitor, ShardManagerOptions};
 use std::sync::Arc;
 use threadpool::ThreadPool;
 use typemap::ShareMap;
@@ -342,53 +342,34 @@ impl Client {
         let data = Arc::new(Mutex::new(ShareMap::custom()));
         let event_handler = Arc::new(handler);
 
-        Ok(feature_framework! {{
-            let framework = Arc::new(Mutex::new(None));
-
-            let (shard_manager, shard_manager_worker) = ShardManager::new(
-                0,
-                0,
-                0,
-                &url,
-                &locked,
-                &data,
-                &event_handler,
-                &framework,
-                threadpool.clone(),
-            );
-
-            Client {
-                token: locked,
-                ws_uri: url,
-                framework,
-                data,
-                shard_manager,
-                shard_manager_worker,
-                threadpool,
-                user_id,
-            }
-        } else {
-            let (shard_manager, shard_manager_worker) = ShardManager::new(
-                0,
-                0,
-                0,
-                Arc::clone(&url),
-                locked.clone(),
-                data.clone(),
-                Arc::clone(&event_handler),
-                threadpool.clone(),
-            );
+        #[cfg(feature = "framework")]
+        let framework = Arc::new(Mutex::new(None));
+        let (shard_manager, shard_manager_worker) = {
+            ShardManager::new(ShardManagerOptions {
+                data: &data,
+                event_handler: &event_handler,
+                #[cfg(feature = "framework")]
+                framework: &framework,
+                shard_index: 0,
+                shard_init: 0,
+                shard_total: 0,
+                threadpool: threadpool.clone(),
+                token: &locked,
+                ws_url: &url,
+            })
+        };
 
-            Client {
-                token: locked,
-                ws_uri: url,
-                data,
-                shard_manager,
-                shard_manager_worker,
-                threadpool,
-                user_id,
-            }
-        }})
+        Ok(Client {
+            token: locked,
+            ws_uri: url,
+            #[cfg(feature = "framework")]
+            framework,
+            data,
+            shard_manager,
+            shard_manager_worker,
+            threadpool,
+            user_id,
+        })
     }
 
     /// Sets a framework to be used with the client. All message events will be