Update most dependency version requirements

Update the dependencies `base64`, `bitflags`, `byteorder`, `serde`,
`serde_derive`, and `serde_json`.

These dependencies have been updated, with byteorder and serde** hitting
v1.0.0, so they should be updated for the v0.2.0 serenity release.

9 files changed, 61 insertions, 60 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 70d454a..c454a88 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -100,7 +100,6 @@ extern crate serde_derive;
 extern crate serde_json;
 
 extern crate base64;
-extern crate byteorder;
 extern crate flate2;
 extern crate hyper;
 extern crate multipart;
@@ -110,6 +109,8 @@ extern crate typemap;
 extern crate websocket;
 
 #[cfg(feature="voice")]
+extern crate byteorder;
+#[cfg(feature="voice")]
 extern crate opus;
 #[cfg(feature="voice")]
 extern crate sodiumoxide;
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 2ad06cf..6600dc7 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -345,8 +345,8 @@ impl Channel {
     }
 }
 
-impl Deserialize for Channel {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for Channel {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let v = JsonMap::deserialize(deserializer)?;
         let kind = {
             let kind = v.get("type").ok_or_else(|| DeError::missing_field("type"))?;
@@ -451,8 +451,8 @@ pub struct PermissionOverwrite {
     pub kind: PermissionOverwriteType,
 }
 
-impl Deserialize for PermissionOverwrite {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<PermissionOverwrite, D::Error> {
+impl<'de> Deserialize<'de> for PermissionOverwrite {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<PermissionOverwrite, D::Error> {
         let data = PermissionOverwriteData::deserialize(deserializer)?;
 
         let kind = match &data.kind[..] {
diff --git a/src/model/event.rs b/src/model/event.rs
index f206a07..5d81b71 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -26,8 +26,8 @@ pub struct ChannelCreateEvent {
     pub channel: Channel,
 }
 
-impl Deserialize for ChannelCreateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ChannelCreateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             channel: Channel::deserialize(deserializer)?,
         })
@@ -39,8 +39,8 @@ pub struct ChannelDeleteEvent {
     pub channel: Channel,
 }
 
-impl Deserialize for ChannelDeleteEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ChannelDeleteEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             channel: Channel::deserialize(deserializer)?,
         })
@@ -70,8 +70,8 @@ pub struct ChannelUpdateEvent {
     pub channel: Channel,
 }
 
-impl Deserialize for ChannelUpdateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ChannelUpdateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             channel: Channel::deserialize(deserializer)?,
         })
@@ -106,8 +106,8 @@ pub struct GuildCreateEvent {
     pub guild: Guild,
 }
 
-impl Deserialize for GuildCreateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for GuildCreateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             guild: Guild::deserialize(deserializer)?,
         })
@@ -119,8 +119,8 @@ pub struct GuildDeleteEvent {
     pub guild: PartialGuild,
 }
 
-impl Deserialize for GuildDeleteEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for GuildDeleteEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             guild: PartialGuild::deserialize(deserializer)?,
         })
@@ -145,8 +145,8 @@ pub struct GuildMemberAddEvent {
     pub member: Member,
 }
 
-impl Deserialize for GuildMemberAddEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for GuildMemberAddEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let map = JsonMap::deserialize(deserializer)?;
 
         let guild_id = map.get("guild_id")
@@ -181,8 +181,8 @@ pub struct GuildMembersChunkEvent {
     pub members: HashMap<UserId, Member>,
 }
 
-impl Deserialize for GuildMembersChunkEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for GuildMembersChunkEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
         let guild_id = map.get("guild_id")
@@ -241,8 +241,8 @@ pub struct GuildUpdateEvent {
     pub guild: PartialGuild,
 }
 
-impl Deserialize for GuildUpdateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for GuildUpdateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             guild: PartialGuild::deserialize(deserializer)?,
         })
@@ -254,8 +254,8 @@ pub struct MessageCreateEvent {
     pub message: Message,
 }
 
-impl Deserialize for MessageCreateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for MessageCreateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             message: Message::deserialize(deserializer)?,
         })
@@ -301,8 +301,8 @@ pub struct PresenceUpdateEvent {
     pub roles: Option<Vec<RoleId>>,
 }
 
-impl Deserialize for PresenceUpdateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for PresenceUpdateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
         let guild_id = match map.remove("guild_id") {
@@ -328,8 +328,8 @@ pub struct PresencesReplaceEvent {
     pub presences: Vec<Presence>,
 }
 
-impl Deserialize for PresencesReplaceEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for PresencesReplaceEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let presences: Vec<Presence> = Deserialize::deserialize(deserializer)?;
 
         Ok(Self {
@@ -343,8 +343,8 @@ pub struct ReactionAddEvent {
     pub reaction: Reaction,
 }
 
-impl Deserialize for ReactionAddEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ReactionAddEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             reaction: Reaction::deserialize(deserializer)?,
         })
@@ -356,8 +356,8 @@ pub struct ReactionRemoveEvent {
     pub reaction: Reaction,
 }
 
-impl Deserialize for ReactionRemoveEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ReactionRemoveEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             reaction: Reaction::deserialize(deserializer)?,
         })
@@ -376,8 +376,8 @@ pub struct ReadyEvent {
     pub ready: Ready,
 }
 
-impl Deserialize for ReadyEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for ReadyEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             ready: Ready::deserialize(deserializer)?,
         })
@@ -408,8 +408,8 @@ pub struct UserUpdateEvent {
     pub current_user: CurrentUser,
 }
 
-impl Deserialize for UserUpdateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for UserUpdateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Self {
             current_user: CurrentUser::deserialize(deserializer)?,
         })
@@ -430,8 +430,8 @@ pub struct VoiceStateUpdateEvent {
     pub voice_state: VoiceState,
 }
 
-impl Deserialize for VoiceStateUpdateEvent {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for VoiceStateUpdateEvent {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let map = JsonMap::deserialize(deserializer)?;
         let guild_id = match map.get("guild_id") {
             Some(v) => Some(GuildId::deserialize(v.clone()).map_err(DeError::custom)?),
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index 826f723..ea2a1b3 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -58,8 +58,8 @@ impl Game {
     }
 }
 
-impl Deserialize for Game {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for Game {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
         let kind = map.remove("type")
             .and_then(|v| GameType::deserialize(v).ok())
@@ -126,8 +126,8 @@ pub struct Presence {
     pub user: Option<Arc<RwLock<User>>>,
 }
 
-impl Deserialize for Presence {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Presence, D::Error> {
+impl<'de> Deserialize<'de> for Presence {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Presence, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
         let mut user_map = map.remove("user")
             .ok_or_else(|| DeError::custom("expected presence user"))
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index c270fe2..bd9a7ee 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -1091,8 +1091,8 @@ impl Guild {
     }
 }
 
-impl Deserialize for Guild {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for Guild {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
         let id = map.get("id")
diff --git a/src/model/mod.rs b/src/model/mod.rs
index 9b15049..f464242 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -286,7 +286,7 @@ impl Region {
 use serde::{Deserialize, Deserializer};
 use std::result::Result as StdResult;
 
-fn deserialize_sync_user<D: Deserializer>(deserializer: D)
+fn deserialize_sync_user<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<Arc<RwLock<User>>, D::Error> {
     Ok(Arc::new(RwLock::new(User::deserialize(deserializer)?)))
 }
diff --git a/src/model/permissions.rs b/src/model/permissions.rs
index 09fad4a..6404aa7 100644
--- a/src/model/permissions.rs
+++ b/src/model/permissions.rs
@@ -482,15 +482,15 @@ impl Permissions {
     }
 }
 
-impl Deserialize for Permissions {
-    fn deserialize<D: Deserializer>(deserializer: D) -> StdResult<Self, D::Error> {
+impl<'de> Deserialize<'de> for Permissions {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         Ok(Permissions::from_bits_truncate(deserializer.deserialize_u64(U64Visitor)?))
     }
 }
 
 struct U64Visitor;
 
-impl Visitor for U64Visitor {
+impl<'de> Visitor<'de> for U64Visitor {
     type Value = u64;
 
     fn expecting(&self, formatter: &mut Formatter) -> FmtResult {
diff --git a/src/model/utils.rs b/src/model/utils.rs
index 3af5e80..68a6e1c 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -11,7 +11,7 @@ use super::permissions::{self, Permissions};
 #[cfg(feature="cache")]
 use ::client::CACHE;
 
-pub fn deserialize_emojis<D: Deserializer>(deserializer: D)
+pub fn deserialize_emojis<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<EmojiId, Emoji>, D::Error> {
     let vec: Vec<Emoji> = Deserialize::deserialize(deserializer)?;
     let mut emojis = HashMap::new();
@@ -23,7 +23,7 @@ pub fn deserialize_emojis<D: Deserializer>(deserializer: D)
     Ok(emojis)
 }
 
-pub fn deserialize_guild_channels<D: Deserializer>(deserializer: D)
+pub fn deserialize_guild_channels<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<ChannelId, Arc<RwLock<GuildChannel>>>, D::Error> {
     let vec: Vec<GuildChannel> = Deserialize::deserialize(deserializer)?;
     let mut map = HashMap::new();
@@ -35,7 +35,7 @@ pub fn deserialize_guild_channels<D: Deserializer>(deserializer: D)
     Ok(map)
 }
 
-pub fn deserialize_members<D: Deserializer>(deserializer: D)
+pub fn deserialize_members<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<UserId, Member>, D::Error> {
     let vec: Vec<Member> = Deserialize::deserialize(deserializer)?;
     let mut members = HashMap::new();
@@ -49,7 +49,7 @@ pub fn deserialize_members<D: Deserializer>(deserializer: D)
     Ok(members)
 }
 
-pub fn deserialize_presences<D: Deserializer>(deserializer: D)
+pub fn deserialize_presences<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<UserId, Presence>, D::Error> {
     let vec: Vec<Presence> = Deserialize::deserialize(deserializer)?;
     let mut presences = HashMap::new();
@@ -61,7 +61,7 @@ pub fn deserialize_presences<D: Deserializer>(deserializer: D)
     Ok(presences)
 }
 
-pub fn deserialize_private_channels<D: Deserializer>(deserializer: D)
+pub fn deserialize_private_channels<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<ChannelId, Channel>, D::Error> {
     let vec: Vec<Channel> = Deserialize::deserialize(deserializer)?;
     let mut private_channels = HashMap::new();
@@ -79,7 +79,7 @@ pub fn deserialize_private_channels<D: Deserializer>(deserializer: D)
     Ok(private_channels)
 }
 
-pub fn deserialize_roles<D: Deserializer>(deserializer: D)
+pub fn deserialize_roles<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<RoleId, Role>, D::Error> {
     let vec: Vec<Role> = Deserialize::deserialize(deserializer)?;
     let mut roles = HashMap::new();
@@ -91,7 +91,7 @@ pub fn deserialize_roles<D: Deserializer>(deserializer: D)
     Ok(roles)
 }
 
-pub fn deserialize_single_recipient<D: Deserializer>(deserializer: D)
+pub fn deserialize_single_recipient<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<Arc<RwLock<User>>, D::Error> {
     let mut users: Vec<User> = Deserialize::deserialize(deserializer)?;
     let user = if users.is_empty() {
@@ -103,7 +103,7 @@ pub fn deserialize_single_recipient<D: Deserializer>(deserializer: D)
     Ok(Arc::new(RwLock::new(user)))
 }
 
-pub fn deserialize_users<D: Deserializer>(deserializer: D)
+pub fn deserialize_users<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<UserId, Arc<RwLock<User>>>, D::Error> {
     let vec: Vec<User> = Deserialize::deserialize(deserializer)?;
     let mut users = HashMap::new();
@@ -115,7 +115,7 @@ pub fn deserialize_users<D: Deserializer>(deserializer: D)
     Ok(users)
 }
 
-pub fn deserialize_voice_states<D: Deserializer>(deserializer: D)
+pub fn deserialize_voice_states<'de, D: Deserializer<'de>>(deserializer: D)
     -> StdResult<HashMap<UserId, VoiceState>, D::Error> {
     let vec: Vec<VoiceState> = Deserialize::deserialize(deserializer)?;
     let mut voice_states = HashMap::new();
diff --git a/src/utils/macros.rs b/src/utils/macros.rs
index 27b3a9b..e51074b 100644
--- a/src/utils/macros.rs
+++ b/src/utils/macros.rs
@@ -119,7 +119,7 @@ macro_rules! feature_voice {
 macro_rules! enum_number {
     (#[$attr_:meta] $name:ident { $(#[$attr:meta] $variant:ident = $value:expr, )* }) => {
         #[$attr_]
-        #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
+        #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
         pub enum $name {
             $(
                 #[$attr]
@@ -136,13 +136,13 @@ macro_rules! enum_number {
             }
         }
 
-        impl ::serde::Deserialize for $name {
+        impl<'de> ::serde::Deserialize<'de> for $name {
             fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
-                where D: ::serde::Deserializer
+                where D: ::serde::Deserializer<'de>
             {
                 struct Visitor;
 
-                impl ::serde::de::Visitor for Visitor {
+                impl<'de> ::serde::de::Visitor<'de> for Visitor {
                     type Value = $name;
 
                     fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {