Remove global Cache (#448)

* Update to use Rust 2018.

* Update examples and use Rust 2018.

* Pass cache via `Context` around instead of being global.

* Remove `lazy_static` from `cache`-feature.

* Update examples to use `Context`'s cache.

* Replace cache's update-timeout-setting with `update_cache_timeout`.

* Update documentation to stop using global cache.

* Move `HttpAndCache` to `lib.rs`.

* Add `__nonexhaustive`-field to `CacheAndHttp`.

* Add `__nonexhaustive` in `CacheAndHttp`-initialisers.

* Avoid `__nonexhaustive`-usage in doctest.

* Remove unnecessary comma in `cfg`-attribute.

1 files changed, 77 insertions, 114 deletions

diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 5ed5f3e..0425f29 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -4,14 +4,13 @@ use crate::model::{
     event::Event,
     guild::Member,
 };
-use std::sync::Arc;
+use std::{sync::{Arc, mpsc::Sender}};
 use parking_lot::Mutex;
 use super::{
     bridge::gateway::event::ClientEvent,
     event_handler::EventHandler,
     Context
 };
-use std::sync::mpsc::Sender;
 use threadpool::ThreadPool;
 use typemap::ShareMap;
 
@@ -20,42 +19,45 @@ use crate::framework::Framework;
 #[cfg(feature = "cache")]
 use crate::model::id::GuildId;
 #[cfg(feature = "cache")]
-use std::time::Duration;
-
+use crate::cache::Cache;
 #[cfg(feature = "cache")]
-use super::CACHE;
-
+use crate::CacheAndHttp;
 #[cfg(feature = "cache")]
-lazy_static! {
-    pub static ref CACHE_TRY_WRITE_DURATION: Option<Duration> =
-        CACHE.read().get_try_write_duration();
-}
+use parking_lot::RwLock;
 
 macro_rules! update {
-    ($event:expr) => {
+    ($cache_and_http:ident, $event:expr) => {
         {
             #[cfg(feature = "cache")]
             {
-                match *CACHE_TRY_WRITE_DURATION {
-                    Some(duration) => {
-                        if let Some(mut lock) = CACHE.try_write_for(duration) {
-                            lock.update(&mut $event)
-                        } else {
-                            warn!(
-                                "[dispatch] Possible deadlock: couldn't unlock cache to update with event: {:?}",
-                                $event,
-                            );
-                            None
-                        }},
-                    None => {
-                        CACHE.write().update(&mut $event)
-                    },
+                if let Some(millis_timeout) = $cache_and_http.update_cache_timeout {
+
+                    if let Some(mut lock) = $cache_and_http.cache.try_write_for(millis_timeout) {
+                        lock.update(&mut $event)
+                    } else {
+                        warn!("[dispatch] Possible deadlock: Couldn't unlock cache to update with event: {:?}", $event);
+
+                        None
+                    }
+                } else {
+                    $cache_and_http.cache.write().update(&mut $event)
                 }
             }
         }
-    };
+    }
 }
 
+#[cfg(feature = "cache")]
+fn context(
+    data: &Arc<Mutex<ShareMap>>,
+    runner_tx: &Sender<InterMessage>,
+    shard_id: u64,
+    cache: &Arc<RwLock<Cache>>,
+) -> Context {
+    Context::new(Arc::clone(data), runner_tx.clone(), shard_id, cache.clone())
+}
+
+#[cfg(not(feature = "cache"))]
 fn context(
     data: &Arc<Mutex<ShareMap>>,
     runner_tx: &Sender<InterMessage>,
@@ -79,12 +81,17 @@ pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
     runner_tx: &Sender<InterMessage>,
     threadpool: &ThreadPool,
     shard_id: u64,
+    cache_and_http: Arc<CacheAndHttp>,
 ) {
     match event {
         DispatchEvent::Model(Event::MessageCreate(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
+            #[cfg(feature = "cache")]
+            let context = context(data, runner_tx, shard_id, &cache_and_http.cache);
+            #[cfg(not(feature = "cache"))]
             let context = context(data, runner_tx, shard_id);
+
             dispatch_message(
                 context.clone(),
                 event.message.clone(),
@@ -103,6 +110,7 @@ pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
             runner_tx,
             threadpool,
             shard_id,
+            cache_and_http,
         ),
     }
 }
@@ -116,12 +124,12 @@ pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
     runner_tx: &Sender<InterMessage>,
     threadpool: &ThreadPool,
     shard_id: u64,
+    cache_and_http: Arc<CacheAndHttp>,
 ) {
     match event {
         DispatchEvent::Model(Event::MessageCreate(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
-            let context = context(data, runner_tx, shard_id);
             dispatch_message(context, event.message, event_handler, threadpool);
         },
         other => handle_event(
@@ -131,6 +139,7 @@ pub(crate) fn dispatch<H: EventHandler + Send + Sync + 'static>(
             runner_tx,
             threadpool,
             shard_id,
+            cache_and_http,
         ),
     }
 }
@@ -162,10 +171,15 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
     runner_tx: &Sender<InterMessage>,
     threadpool: &ThreadPool,
     shard_id: u64,
+    cache_and_http: Arc<CacheAndHttp>,
 ) {
+    #[cfg(feature = "cache")]
+    let context = context(data, runner_tx, shard_id, &cache_and_http.cache);
+    #[cfg(not(feature = "cache"))]
+    let context = context(data, runner_tx, shard_id);
+
     match event {
         DispatchEvent::Client(ClientEvent::ShardStageUpdate(event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -173,10 +187,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         }
         DispatchEvent::Model(Event::ChannelCreate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
-
+            update!(cache_and_http, event);
             // Discord sends both a MessageCreate and a ChannelCreate upon a new message in a private channel.
             // This could potentially be annoying to handle when otherwise wanting to normally take care of a new channel.
             // So therefore, private channels are dispatched to their own handler code.
@@ -206,9 +217,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             }
         },
         DispatchEvent::Model(Event::ChannelDelete(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
 
             match event.channel {
                 Channel::Private(_) | Channel::Group(_) => {},
@@ -229,7 +238,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             }
         },
         DispatchEvent::Model(Event::ChannelPinsUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
+
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -237,9 +246,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ChannelRecipientAdd(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
 
             let event_handler = Arc::clone(event_handler);
 
@@ -252,9 +259,8 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ChannelRecipientRemove(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -266,14 +272,13 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ChannelUpdate(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
                 feature_cache! {{
-                    let before = CACHE.read().channel(event.channel.id());
+                    let before = cache_and_http.cache.read().channel(event.channel.id());
 
                     event_handler.channel_update(context, before, event.channel);
                 } else {
@@ -282,7 +287,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildBanAdd(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -290,7 +294,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildBanRemove(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
+
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -300,21 +304,20 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
         DispatchEvent::Model(Event::GuildCreate(mut event)) => {
             #[cfg(feature = "cache")]
             let _is_new = {
-                let cache = CACHE.read();
+                let cache = cache_and_http.cache.read();
 
                 !cache.unavailable_guilds.contains(&event.guild.id)
             };
 
-            update!(event);
+            update!(cache_and_http, event);
 
             #[cfg(feature = "cache")]
             {
-                let cache = CACHE.read();
-
-                if cache.unavailable_guilds.is_empty() {
-                    let context = context(data, runner_tx, shard_id);
+                let locked_cache = cache_and_http.cache.read();
+                let context = context.clone();
 
-                    let guild_amount = cache
+                if locked_cache.unavailable_guilds.is_empty() {
+                    let guild_amount = locked_cache
                         .guilds
                         .iter()
                         .map(|(&id, _)| id)
@@ -327,7 +330,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
                 }
             }
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -339,8 +341,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildDelete(mut event)) => {
-            let _full = update!(event);
-            let context = context(data, runner_tx, shard_id);
+            let _full = update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -352,9 +353,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildEmojisUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -362,7 +361,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildIntegrationsUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -370,9 +368,8 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildMemberAdd(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -380,8 +377,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildMemberRemove(mut event)) => {
-            let _member = update!(event);
-            let context = context(data, runner_tx, shard_id);
+            let _member = update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -393,15 +389,13 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildMemberUpdate(mut event)) => {
-            let _before = update!(event);
-
+            let _before = update!(cache_and_http, event);
             let _after: Option<Member> = feature_cache! {{
-                CACHE.read().member(event.guild_id, event.user.id)
+                cache_and_http.cache.read().member(event.guild_id, event.user.id)
             } else {
                 None
             }};
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -415,9 +409,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildMembersChunk(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -425,9 +417,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildRoleCreate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -435,8 +425,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildRoleDelete(mut event)) => {
-            let _role = update!(event);
-            let context = context(data, runner_tx, shard_id);
+            let _role = update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -448,8 +437,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildRoleUpdate(mut event)) => {
-            let _before = update!(event);
-            let context = context(data, runner_tx, shard_id);
+            let _before = update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -461,9 +449,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildUnavailable(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -471,14 +457,12 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::GuildUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
                 feature_cache! {{
-                    let before = CACHE.read()
+                    let before = cache_and_http.cache.read()
                         .guilds
                         .get(&event.guild.id)
                         .cloned();
@@ -492,7 +476,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
         // Already handled by the framework check macro
         DispatchEvent::Model(Event::MessageCreate(_)) => {},
         DispatchEvent::Model(Event::MessageDeleteBulk(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -500,7 +483,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::MessageDelete(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -508,9 +490,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::MessageUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -518,9 +498,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::PresencesReplace(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -528,9 +506,8 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::PresenceUpdate(mut event)) => {
-            update!(event);
+            update!(cache_and_http, event);
 
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -538,7 +515,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ReactionAdd(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -546,7 +522,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ReactionRemove(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -554,7 +529,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::ReactionRemoveAll(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -562,9 +536,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::Ready(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(&event_handler);
 
             threadpool.execute(move || {
@@ -572,12 +544,9 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::Resumed(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
-
             event_handler.resume(context, event);
         },
         DispatchEvent::Model(Event::TypingStart(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -585,7 +554,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::Unknown(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -593,8 +561,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::UserUpdate(mut event)) => {
-            let _before = update!(event);
-            let context = context(data, runner_tx, shard_id);
+            let _before = update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -606,7 +573,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::VoiceServerUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -614,9 +580,7 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::VoiceStateUpdate(mut event)) => {
-            update!(event);
-
-            let context = context(data, runner_tx, shard_id);
+            update!(cache_and_http, event);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
@@ -624,7 +588,6 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::WebhookUpdate(mut event)) => {
-            let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {