Improve performance of builders even further

By negating hashing altogether.

The increase is around 1000-ish nanoseconds saved.

10 files changed, 33 insertions, 31 deletions

diff --git a/src/model/channel/channel_category.rs b/src/model/channel/channel_category.rs
index f6df342..7d6c900 100644
--- a/src/model/channel/channel_category.rs
+++ b/src/model/channel/channel_category.rs
@@ -1,4 +1,6 @@
 use model::prelude::*;
+#[cfg(feature = "model")]
+use builder::VecMap;
 
 #[cfg(all(feature = "builder", feature = "model"))]
 use builder::EditChannel;
@@ -93,12 +95,12 @@ impl ChannelCategory {
             }
         }
 
-        let mut map = HashMap::new();
+        let mut map = VecMap::new();
         map.insert("name", Value::String(self.name.clone()));
         map.insert("position", Value::Number(Number::from(self.position)));
         map.insert("type", Value::String(self.kind.name().to_string()));
 
-        let map = serenity_utils::hashmap_to_json_map(f(EditChannel(map)).0);
+        let map = serenity_utils::vecmap_to_json_map(f(EditChannel(map)).0);
 
         http::edit_channel(self.id.0, &map).map(|channel| {
             let GuildChannel {
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index 7ec6dfe..8ebdf2a 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -191,7 +191,7 @@ impl ChannelId {
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     #[inline]
     pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel> {
-        let map = utils::hashmap_to_json_map(f(EditChannel::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditChannel::default()).0);
 
         http::edit_channel(self.0, &map)
     }
@@ -219,7 +219,7 @@ impl ChannelId {
         where F: FnOnce(CreateMessage) -> CreateMessage, M: Into<MessageId> {
         let msg = f(CreateMessage::default());
 
-        if let Some(content) = msg.0.get("content") {
+        if let Some(content) = msg.0.get(&"content") {
             if let Value::String(ref content) = *content {
                 if let Some(length_over) = Message::overflow_length(content) {
                     return Err(Error::Model(ModelError::MessageTooLong(length_over)));
@@ -227,7 +227,7 @@ impl ChannelId {
             }
         }
 
-        let map = utils::hashmap_to_json_map(msg.0);
+        let map = utils::vecmap_to_json_map(msg.0);
 
         http::edit_message(self.0, message_id.into().0, &Value::Object(map))
     }
@@ -282,13 +282,13 @@ impl ChannelId {
     pub fn messages<F>(&self, f: F) -> Result<Vec<Message>>
         where F: FnOnce(GetMessages) -> GetMessages {
         let mut map = f(GetMessages::default()).0;
-        let mut query = format!("?limit={}", map.remove("limit").unwrap_or(50));
+        let mut query = format!("?limit={}", map.remove(&"limit").unwrap_or(50));
 
-        if let Some(after) = map.remove("after") {
+        if let Some(after) = map.remove(&"after") {
             write!(query, "&after={}", after)?;
-        } else if let Some(around) = map.remove("around") {
+        } else if let Some(around) = map.remove(&"around") {
             write!(query, "&around={}", around)?;
-        } else if let Some(before) = map.remove("before") {
+        } else if let Some(before) = map.remove(&"before") {
             write!(query, "&before={}", before)?;
         }
 
@@ -453,7 +453,7 @@ impl ChannelId {
         where F: FnOnce(CreateMessage) -> CreateMessage, T: Into<AttachmentType<'a>> {
         let mut msg = f(CreateMessage::default());
 
-        if let Some(content) = msg.0.get("content") {
+        if let Some(content) = msg.0.get(&"content") {
             if let Value::String(ref content) = *content {
                 if let Some(length_over) = Message::overflow_length(content) {
                     return Err(Error::Model(ModelError::MessageTooLong(length_over)));
@@ -461,8 +461,8 @@ impl ChannelId {
             }
         }
 
-        let _ = msg.0.remove("embed");
-        let map = utils::hashmap_to_json_map(msg.0);
+        let _ = msg.0.remove(&"embed");
+        let map = utils::vecmap_to_json_map(msg.0);
 
         http::send_files(self.0, files, map)
     }
@@ -489,7 +489,7 @@ impl ChannelId {
     pub fn send_message<F>(&self, f: F) -> Result<Message>
         where F: FnOnce(CreateMessage) -> CreateMessage {
         let msg = f(CreateMessage::default());
-        let map = utils::hashmap_to_json_map(msg.0);
+        let map = utils::vecmap_to_json_map(msg.0);
 
         Message::check_content_length(&map)?;
         Message::check_embed_length(&map)?;
diff --git a/src/model/channel/embed.rs b/src/model/channel/embed.rs
index 3cbe5ac..5359ed5 100644
--- a/src/model/channel/embed.rs
+++ b/src/model/channel/embed.rs
@@ -88,7 +88,7 @@ impl Embed {
     #[inline]
     pub fn fake<F>(f: F) -> Value
         where F: FnOnce(CreateEmbed) -> CreateEmbed {
-        let map = utils::hashmap_to_json_map(f(CreateEmbed::default()).0);
+        let map = utils::vecmap_to_json_map(f(CreateEmbed::default()).0);
 
         Value::Object(map)
     }
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 9b8371d..c598314 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -4,7 +4,7 @@ use model::prelude::*;
 #[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
-use builder::{CreateInvite, CreateMessage, EditChannel, GetMessages};
+use builder::{VecMap, CreateInvite, CreateMessage, EditChannel, GetMessages};
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
 #[cfg(all(feature = "cache", feature = "model"))]
@@ -116,7 +116,7 @@ impl GuildChannel {
             }
         }
 
-        let map = serenity_utils::hashmap_to_json_map(f(CreateInvite::default()).0);
+        let map = serenity_utils::vecmap_to_json_map(f(CreateInvite::default()).0);
 
         http::create_invite(self.id.0, &map)
     }
@@ -312,12 +312,12 @@ impl GuildChannel {
             }
         }
 
-        let mut map = HashMap::new();
+        let mut map = VecMap::new();
         map.insert("name", Value::String(self.name.clone()));
         map.insert("position", Value::Number(Number::from(self.position)));
         map.insert("type", Value::String(self.kind.name().to_string()));
 
-        let edited = serenity_utils::hashmap_to_json_map(f(EditChannel(map)).0);
+        let edited = serenity_utils::vecmap_to_json_map(f(EditChannel(map)).0);
 
         match http::edit_channel(self.id.0, &edited) {
             Ok(channel) => {
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index f139aab..315dc24 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -229,7 +229,7 @@ impl Message {
             builder = builder.tts(true);
         }
 
-        let map = serenity_utils::hashmap_to_json_map(f(builder).0);
+        let map = serenity_utils::vecmap_to_json_map(f(builder).0);
 
         match http::edit_message(self.channel_id.0, self.id.0, &Value::Object(map)) {
             Ok(edited) => {
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index 2453fc6..48ad55b 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -174,7 +174,7 @@ impl GuildId {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
     pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
-        let map = utils::hashmap_to_json_map(f(EditRole::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditRole::default()).0);
 
         http::create_role(self.0, &map)
     }
@@ -237,7 +237,7 @@ impl GuildId {
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
     pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild> {
-        let map = utils::hashmap_to_json_map(f(EditGuild::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditGuild::default()).0);
 
         http::edit_guild(self.0, &map)
     }
@@ -276,7 +276,7 @@ impl GuildId {
     #[inline]
     pub fn edit_member<F, U>(&self, user_id: U, f: F) -> Result<()>
         where F: FnOnce(EditMember) -> EditMember, U: Into<UserId> {
-        let map = utils::hashmap_to_json_map(f(EditMember::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditMember::default()).0);
 
         http::edit_member(self.0, user_id.into().0, &map)
     }
@@ -312,7 +312,7 @@ impl GuildId {
     #[inline]
     pub fn edit_role<F, R>(&self, role_id: R, f: F) -> Result<Role>
         where F: FnOnce(EditRole) -> EditRole, R: Into<RoleId> {
-        let map = utils::hashmap_to_json_map(f(EditRole::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditRole::default()).0);
 
         http::edit_role(self.0, role_id.into().0, &map)
     }
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 166eb55..f2e798a 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -109,7 +109,7 @@ impl Member {
         self.roles.extend_from_slice(role_ids);
 
         let builder = EditMember::default().roles(&self.roles);
-        let map = utils::hashmap_to_json_map(builder.0);
+        let map = utils::vecmap_to_json_map(builder.0);
 
         match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
@@ -227,7 +227,7 @@ impl Member {
     /// [`EditMember`]: ../builder/struct.EditMember.html
     #[cfg(feature = "cache")]
     pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()> {
-        let map = utils::hashmap_to_json_map(f(EditMember::default()).0);
+        let map = utils::vecmap_to_json_map(f(EditMember::default()).0);
 
         http::edit_member(self.guild_id.0, self.user.read().id.0, &map)
     }
@@ -352,7 +352,7 @@ impl Member {
         self.roles.retain(|r| !role_ids.contains(r));
 
         let builder = EditMember::default().roles(&self.roles);
-        let map = utils::hashmap_to_json_map(builder.0);
+        let map = utils::vecmap_to_json_map(builder.0);
 
         match http::edit_member(self.guild_id.0, self.user.read().id.0, &map) {
             Ok(()) => Ok(()),
diff --git a/src/model/invite.rs b/src/model/invite.rs
index ed3455c..5429656 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -75,7 +75,7 @@ impl Invite {
             }
         }
 
-        let map = utils::hashmap_to_json_map(f(CreateInvite::default()).0);
+        let map = utils::vecmap_to_json_map(f(CreateInvite::default()).0);
 
         http::create_invite(channel_id.0, &map)
     }
diff --git a/src/model/user.rs b/src/model/user.rs
index 414f741..fc1ec3a 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -10,7 +10,7 @@ use model::misc::Mentionable;
 #[cfg(all(feature = "cache", feature = "model"))]
 use CACHE;
 #[cfg(feature = "model")]
-use builder::{CreateMessage, EditProfile};
+use builder::{VecMap, CreateMessage, EditProfile};
 #[cfg(feature = "model")]
 use chrono::NaiveDateTime;
 #[cfg(feature = "model")]
@@ -90,14 +90,14 @@ impl CurrentUser {
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditProfile) -> EditProfile {
-        let mut map = HashMap::new();
+        let mut map = VecMap::new();
         map.insert("username", Value::String(self.name.clone()));
 
         if let Some(email) = self.email.as_ref() {
             map.insert("email", Value::String(email.clone()));
         }
 
-        let map = utils::hashmap_to_json_map(f(EditProfile(map)).0);
+        let map = utils::vecmap_to_json_map(f(EditProfile(map)).0);
 
         match http::edit_profile(&map) {
             Ok(new) => {
diff --git a/src/model/webhook.rs b/src/model/webhook.rs
index d834502..d9a4483 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -187,7 +187,7 @@ impl Webhook {
                                                                 wait: bool,
                                                                 f: F)
                                                                 -> Result<Option<Message>> {
-        let map = utils::hashmap_to_json_map(f(ExecuteWebhook::default()).0);
+        let map = utils::vecmap_to_json_map(f(ExecuteWebhook::default()).0);
 
         http::execute_webhook(self.id.0, &self.token, wait, &map)
     }