Revamp `RwLock` usage in the lib

Also not quite sure if they goofed rustfmt or something, but its changes it did were a bit bizarre.

2 files changed, 93 insertions, 117 deletions

diff --git a/src/cache/cache_events_impl.rs b/src/cache/cache_events_impl.rs
index cbf0e77..0b511b2 100644
--- a/src/cache/cache_events_impl.rs
+++ b/src/cache/cache_events_impl.rs
@@ -5,6 +5,7 @@ use std::sync::{Arc, RwLock};
 use std::mem;
 use model::*;
 use model::event::*;
+use internal::RwLockExt;
 
 pub(crate) trait CacheEventsImpl {
     fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel>;
@@ -62,64 +63,52 @@ impl CacheEventsImpl for super::Cache {
             Channel::Group(ref group) => {
                 let group = group.clone();
 
-                let channel_id = {
-                    let writer = group.write().unwrap();
-
-                    for (recipient_id, recipient) in &mut group.write().unwrap().recipients {
+                let channel_id = group.with_mut(|writer| {
+                    for (recipient_id, recipient) in &mut writer.recipients {
                         self.update_user_entry(&recipient.read().unwrap());
 
                         *recipient = self.users[recipient_id].clone();
                     }
 
                     writer.channel_id
-                };
+                });
 
                 let ch = self.groups.insert(channel_id, group);
 
                 ch.map(Channel::Group)
             },
             Channel::Guild(ref channel) => {
-                let (guild_id, channel_id) = {
-                    let channel = channel.read().unwrap();
-
-                    (channel.guild_id, channel.id)
-                };
+                let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
                 self.channels.insert(channel_id, channel.clone());
 
                 self.guilds
                     .get_mut(&guild_id)
                     .and_then(|guild| {
-                        guild.write().unwrap().channels.insert(
-                            channel_id,
-                            channel.clone(),
-                        )
+                        guild
+                            .with_mut(|guild| guild.channels.insert(channel_id, channel.clone()))
                     })
                     .map(Channel::Guild)
             },
             Channel::Private(ref channel) => {
-                if let Some(channel) = self.private_channels.get(&channel.read().unwrap().id) {
+                if let Some(channel) = self.private_channels.get(&channel.with(|c| c.id)) {
                     return Some(Channel::Private((*channel).clone()));
                 }
 
                 let channel = channel.clone();
 
-                let mut channel_writer = channel.write().unwrap();
-
-                let user_id = {
-                    let user_reader = channel_writer.recipient.read().unwrap();
-
-                    self.update_user_entry(&user_reader);
+                let id = channel.with_mut(|writer| {
+                    let user_id = writer.recipient.with_mut(|user| {
+                        self.update_user_entry(&user);
 
-                    user_reader.id
-                };
+                        user.id
+                    });
 
-                channel_writer.recipient = self.users[&user_id].clone();
+                    writer.recipient = self.users[&user_id].clone();
+                    writer.id
+                });
 
-                let ch = self.private_channels.insert(
-                    channel_writer.id,
-                    channel.clone(),
-                );
+                let ch = self.private_channels.insert(id, channel.clone());
                 ch.map(Channel::Private)
             },
         }
@@ -131,70 +120,66 @@ impl CacheEventsImpl for super::Cache {
             // We ignore these two due to the fact that the delete event for dms/groups
             // will _not_ fire
             // anymore.
-            Channel::Private(_) |
-            Channel::Group(_) => unreachable!(),
+            Channel::Private(_) | Channel::Group(_) => unreachable!(),
         };
 
-        let (channel_id, guild_id) = {
-            let channel = channel.read().unwrap();
-
-            (channel.id, channel.guild_id)
-        };
+        let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
         self.channels.remove(&channel_id);
 
-        self.guilds.get_mut(&guild_id).and_then(|guild| {
-            guild.write().unwrap().channels.remove(&channel_id)
-        });
+        self.guilds
+            .get_mut(&guild_id)
+            .and_then(|guild| guild.with_mut(|g| g.channels.remove(&channel_id)));
     }
 
     #[allow(dead_code)]
-    fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent) {
+fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent){
         if let Some(channel) = self.channels.get(&event.channel_id) {
-            channel.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            channel
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
 
         if let Some(channel) = self.private_channels.get_mut(&event.channel_id) {
-            channel.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            channel
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
 
         if let Some(group) = self.groups.get_mut(&event.channel_id) {
-            group.write().unwrap().last_pin_timestamp = event.last_pin_timestamp;
+            group
+                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
 
             return;
         }
     }
 
-    fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent) {
+fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent){
         self.update_user_entry(&event.user);
         let user = self.users[&event.user.id].clone();
 
         self.groups.get_mut(&event.channel_id).map(|group| {
-            group.write().unwrap().recipients.insert(
-                event.user.id,
-                user,
-            );
+            group
+                .write()
+                .unwrap()
+                .recipients
+                .insert(event.user.id, user);
         });
     }
 
-    fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent) {
+fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent){
         self.groups.get_mut(&event.channel_id).map(|group| {
-            group.write().unwrap().recipients.remove(&event.user.id)
+            group.with_mut(|g| g.recipients.remove(&event.user.id))
         });
     }
 
     fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent) {
         match event.channel {
             Channel::Group(ref group) => {
-                let (ch_id, no_recipients) = {
-                    let group = group.read().unwrap();
-
-                    (group.channel_id, group.recipients.is_empty())
-                };
+                let (ch_id, no_recipients) =
+                    group.with(|g| (g.channel_id, g.recipients.is_empty()));
 
                 match self.groups.entry(ch_id) {
                     Entry::Vacant(e) => {
@@ -216,18 +201,12 @@ impl CacheEventsImpl for super::Cache {
                 }
             },
             Channel::Guild(ref channel) => {
-                let (channel_id, guild_id) = {
-                    let channel = channel.read().unwrap();
-
-                    (channel.id, channel.guild_id)
-                };
+                let (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
                 self.channels.insert(channel_id, channel.clone());
                 self.guilds.get_mut(&guild_id).map(|guild| {
-                    guild.write().unwrap().channels.insert(
-                        channel_id,
-                        channel.clone(),
-                    )
+                    guild
+                        .with_mut(|g| g.channels.insert(channel_id, channel.clone()))
                 });
             },
             Channel::Private(ref channel) => {
@@ -251,16 +230,14 @@ impl CacheEventsImpl for super::Cache {
         }
 
         self.channels.extend(guild.channels.clone());
-        self.guilds.insert(
-            event.guild.id,
-            Arc::new(RwLock::new(guild)),
-        );
+        self.guilds
+            .insert(event.guild.id, Arc::new(RwLock::new(guild)));
     }
 
     fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent) -> Option<Arc<RwLock<Guild>>> {
         // Remove channel entries for the guild if the guild is found.
         self.guilds.remove(&event.guild.id).map(|guild| {
-            for channel_id in guild.read().unwrap().channels.keys() {
+            for channel_id in guild.write().unwrap().channels.keys() {
                 self.channels.remove(channel_id);
             }
 
@@ -268,41 +245,41 @@ impl CacheEventsImpl for super::Cache {
         })
     }
 
-    fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent) {
+fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent){
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().emojis.extend(event.emojis.clone())
+            guild.with_mut(|g| g.emojis.extend(event.emojis.clone()))
         });
     }
 
-    fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
-        let user_id = event.member.user.read().unwrap().id;
+fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
+        let user_id = event.member.user.with(|u| u.id);
         self.update_user_entry(&event.member.user.read().unwrap());
 
         // Always safe due to being inserted above.
         event.member.user = self.users[&user_id].clone();
 
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            let mut guild = guild.write().unwrap();
-
-            guild.member_count += 1;
-            guild.members.insert(user_id, event.member.clone());
+            guild.with_mut(|guild| {
+                guild.member_count += 1;
+                guild.members.insert(user_id, event.member.clone());
+            })
         });
     }
 
     fn update_with_guild_member_remove(&mut self,
                                        event: &GuildMemberRemoveEvent)
-                                       -> Option<Member> {
+-> Option<Member>{
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            let mut guild = guild.write().unwrap();
-
-            guild.member_count -= 1;
-            guild.members.remove(&event.user.id)
+            guild.with_mut(|guild| {
+                guild.member_count -= 1;
+                guild.members.remove(&event.user.id)
+            })
         })
     }
 
     fn update_with_guild_member_update(&mut self,
                                        event: &GuildMemberUpdateEvent)
-                                       -> Option<Member> {
+-> Option<Member>{
         self.update_user_entry(&event.user);
 
         if let Some(guild) = self.guilds.get_mut(&event.guild_id) {
@@ -345,40 +322,43 @@ impl CacheEventsImpl for super::Cache {
         }
     }
 
-    fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent) {
+fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent){
         for member in event.members.values() {
             self.update_user_entry(&member.user.read().unwrap());
         }
 
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().members.extend(event.members.clone())
+            guild.with_mut(|g| g.members.extend(event.members.clone()))
         });
     }
 
-    fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
+fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent){
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild.write().unwrap().roles.insert(
-                event.role.id,
-                event.role.clone(),
-            )
+            guild
+                .write()
+                .unwrap()
+                .roles
+                .insert(event.role.id, event.role.clone())
         });
     }
 
-    fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role> {
-        self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            guild.write().unwrap().roles.remove(&event.role_id)
-        })
+fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role>{
+        self.guilds
+            .get_mut(&event.guild_id)
+            .and_then(|guild| guild.with_mut(|g| g.roles.remove(&event.role_id)))
     }
 
-    fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role> {
+fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role>{
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            guild.write().unwrap().roles.get_mut(&event.role.id).map(
-                |role| mem::replace(role, event.role.clone()),
-            )
+            guild.with_mut(|g| {
+                g.roles
+                    .get_mut(&event.role.id)
+                    .map(|role| mem::replace(role, event.role.clone()))
+            })
         })
     }
 
-    fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent) {
+fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent){
         self.unavailable_guilds.insert(event.guild_id);
         self.guilds.remove(&event.guild_id);
     }
@@ -398,7 +378,7 @@ impl CacheEventsImpl for super::Cache {
         });
     }
 
-    fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
+fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent){
         self.presences.extend({
             let mut p: HashMap<UserId, Presence> = HashMap::default();
 
@@ -426,19 +406,16 @@ impl CacheEventsImpl for super::Cache {
                 if event.presence.status == OnlineStatus::Offline {
                     guild.presences.remove(&event.presence.user_id);
                 } else {
-                    guild.presences.insert(
-                        event.presence.user_id,
-                        event.presence.clone(),
-                    );
+                    guild
+                        .presences
+                        .insert(event.presence.user_id, event.presence.clone());
                 }
             }
         } else if event.presence.status == OnlineStatus::Offline {
             self.presences.remove(&event.presence.user_id);
         } else {
-            self.presences.insert(
-                event.presence.user_id,
-                event.presence.clone(),
-            );
+            self.presences
+                .insert(event.presence.user_id, event.presence.clone());
         }
     }
 
@@ -479,7 +456,7 @@ impl CacheEventsImpl for super::Cache {
         mem::replace(&mut self.user, event.current_user.clone())
     }
 
-    fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent) {
+fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent){
         if let Some(guild_id) = event.guild_id {
             if let Some(guild) = self.guilds.get_mut(&guild_id) {
                 let mut guild = guild.write().unwrap();
@@ -496,10 +473,9 @@ impl CacheEventsImpl for super::Cache {
                         }
                     }
 
-                    guild.voice_states.insert(
-                        event.voice_state.user_id,
-                        event.voice_state.clone(),
-                    );
+                    guild
+                        .voice_states
+                        .insert(event.voice_state.user_id, event.voice_state.clone());
                 } else {
                     // Remove the user from the voice state list
                     guild.voice_states.remove(&event.voice_state.user_id);
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 68a78a7..4aa587f 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -482,7 +482,7 @@ impl Cache {
     pub fn member<G, U>(&self, guild_id: G, user_id: U) -> Option<Member>
         where G: Into<GuildId>, U: Into<UserId> {
         self.guilds.get(&guild_id.into()).and_then(|guild| {
-            guild.write().unwrap().members.get(&user_id.into()).cloned()
+            guild.read().unwrap().members.get(&user_id.into()).cloned()
         })
     }
 
@@ -517,7 +517,7 @@ impl Cache {
     #[inline]
     pub fn private_channel<C: Into<ChannelId>>(&self,
                                                channel_id: C)
-                                               -> Option<Arc<RwLock<PrivateChannel>>> {
+-> Option<Arc<RwLock<PrivateChannel>>>{
         self.private_channels.get(&channel_id.into()).cloned()
     }
 
@@ -553,9 +553,9 @@ impl Cache {
     /// ```
     pub fn role<G, R>(&self, guild_id: G, role_id: R) -> Option<Role>
         where G: Into<GuildId>, R: Into<RoleId> {
-        self.guilds.get(&guild_id.into()).and_then(|g| {
-            g.read().unwrap().roles.get(&role_id.into()).cloned()
-        })
+        self.guilds
+            .get(&guild_id.into())
+            .and_then(|g| g.read().unwrap().roles.get(&role_id.into()).cloned())
     }
 
     /// Retrieves a `User` from the cache's [`users`] map, if it exists.