perf(model/gateway)!: Optimize Event size

cache/in-memory/src/event/channel.rs

@@ -185,8 +185,8 @@ mod tests {
             .unwrap()
             .contains(&channel_id));
 
-        cache.update(&Event::ChannelDelete(ChannelDelete(Channel::Guild(
-            channel,
+        cache.update(&Event::ChannelDelete(Box::new(ChannelDelete(
+            Channel::Guild(channel),
         ))));
         assert!(cache.channels_guild.is_empty());
         assert!(cache.guild_channels.get(&guild_id).unwrap().is_empty());

cache/in-memory/src/lib.rs

@@ -928,25 +928,25 @@ impl UpdateCache for Event {
         match self {
             BanAdd(_) => {}
             BanRemove(_) => {}
-            ChannelCreate(v) => c.update(v),
-            ChannelDelete(v) => c.update(v),
+            ChannelCreate(v) => c.update(v.deref()),
+            ChannelDelete(v) => c.update(v.deref()),
             ChannelPinsUpdate(v) => c.update(v),
-            ChannelUpdate(v) => c.update(v),
+            ChannelUpdate(v) => c.update(v.deref()),
             GatewayHeartbeat(_) => {}
             GatewayHeartbeatAck => {}
             GatewayHello(_) => {}
             GatewayInvalidateSession(_v) => {}
             GatewayReconnect => {}
             GiftCodeUpdate => {}
             GuildCreate(v) => c.update(v.deref()),
-            GuildDelete(v) => c.update(v.deref()),
+            GuildDelete(v) => c.update(v),
             GuildEmojisUpdate(v) => c.update(v),
             GuildIntegrationsUpdate(_) => {}
             GuildUpdate(v) => c.update(v.deref()),
             IntegrationCreate(v) => c.update(v.deref()),
             IntegrationDelete(v) => c.update(v.deref()),
             IntegrationUpdate(v) => c.update(v.deref()),
-            InteractionCreate(v) => c.update(v.deref()),
+            InteractionCreate(v) => c.update(v),
             InviteCreate(_) => {}
             InviteDelete(_) => {}
             MemberAdd(v) => c.update(v.deref()),
@@ -978,8 +978,8 @@ impl UpdateCache for Event {
             StageInstanceCreate(v) => c.update(v),
             StageInstanceDelete(v) => c.update(v),
             StageInstanceUpdate(v) => c.update(v),
-            ThreadCreate(v) => c.update(v),
-            ThreadUpdate(v) => c.update(v),
+            ThreadCreate(v) => c.update(v.deref()),
+            ThreadUpdate(v) => c.update(v.deref()),
             ThreadDelete(v) => c.update(v),
             ThreadListSync(v) => c.update(v),
             ThreadMemberUpdate(_) => {}

model/src/gateway/event/dispatch.rs

@@ -16,20 +16,20 @@ use serde::{
 pub enum DispatchEvent {
     BanAdd(BanAdd),
     BanRemove(BanRemove),
-    ChannelCreate(ChannelCreate),
-    ChannelDelete(ChannelDelete),
+    ChannelCreate(Box<ChannelCreate>),
+    ChannelDelete(Box<ChannelDelete>),
     ChannelPinsUpdate(ChannelPinsUpdate),
-    ChannelUpdate(ChannelUpdate),
+    ChannelUpdate(Box<ChannelUpdate>),
     GiftCodeUpdate,
     GuildCreate(Box<GuildCreate>),
-    GuildDelete(Box<GuildDelete>),
+    GuildDelete(GuildDelete),
     GuildEmojisUpdate(GuildEmojisUpdate),
     GuildIntegrationsUpdate(GuildIntegrationsUpdate),
     GuildUpdate(Box<GuildUpdate>),
     IntegrationCreate(Box<IntegrationCreate>),
     IntegrationDelete(IntegrationDelete),
     IntegrationUpdate(Box<IntegrationUpdate>),
-    InteractionCreate(Box<InteractionCreate>),
+    InteractionCreate(InteractionCreate),
     InviteCreate(Box<InviteCreate>),
     InviteDelete(InviteDelete),
     MemberAdd(Box<MemberAdd>),
@@ -54,12 +54,12 @@ pub enum DispatchEvent {
     StageInstanceCreate(StageInstanceCreate),
     StageInstanceDelete(StageInstanceDelete),
     StageInstanceUpdate(StageInstanceUpdate),
-    ThreadCreate(ThreadCreate),
+    ThreadCreate(Box<ThreadCreate>),
     ThreadDelete(ThreadDelete),
     ThreadListSync(ThreadListSync),
-    ThreadMemberUpdate(ThreadMemberUpdate),
+    ThreadMemberUpdate(Box<ThreadMemberUpdate>),
     ThreadMembersUpdate(ThreadMembersUpdate),
-    ThreadUpdate(ThreadUpdate),
+    ThreadUpdate(Box<ThreadUpdate>),
     TypingStart(Box<TypingStart>),
     UnavailableGuild(UnavailableGuild),
     UserUpdate(UserUpdate),
@@ -211,16 +211,16 @@ impl<'de, 'a> DeserializeSeed<'de> for DispatchEventWithTypeDeserializer<'a> {
     fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
         Ok(match self.0 {
             "CHANNEL_CREATE" => {
-                DispatchEvent::ChannelCreate(ChannelCreate::deserialize(deserializer)?)
+                DispatchEvent::ChannelCreate(Box::new(ChannelCreate::deserialize(deserializer)?))
             }
             "CHANNEL_DELETE" => {
-                DispatchEvent::ChannelDelete(ChannelDelete::deserialize(deserializer)?)
+                DispatchEvent::ChannelDelete(Box::new(ChannelDelete::deserialize(deserializer)?))
             }
             "CHANNEL_PINS_UPDATE" => {
                 DispatchEvent::ChannelPinsUpdate(ChannelPinsUpdate::deserialize(deserializer)?)
             }
             "CHANNEL_UPDATE" => {
-                DispatchEvent::ChannelUpdate(ChannelUpdate::deserialize(deserializer)?)
+                DispatchEvent::ChannelUpdate(Box::new(ChannelUpdate::deserialize(deserializer)?))
             }
             "GIFT_CODE_UPDATE" => {
                 deserializer.deserialize_ignored_any(IgnoredAny)?;
@@ -232,9 +232,7 @@ impl<'de, 'a> DeserializeSeed<'de> for DispatchEventWithTypeDeserializer<'a> {
             "GUILD_CREATE" => {
                 DispatchEvent::GuildCreate(Box::new(GuildCreate::deserialize(deserializer)?))
             }
-            "GUILD_DELETE" => {
-                DispatchEvent::GuildDelete(Box::new(GuildDelete::deserialize(deserializer)?))
-            }
+            "GUILD_DELETE" => DispatchEvent::GuildDelete(GuildDelete::deserialize(deserializer)?),
             "GUILD_EMOJIS_UPDATE" => {
                 DispatchEvent::GuildEmojisUpdate(GuildEmojisUpdate::deserialize(deserializer)?)
             }
@@ -274,9 +272,9 @@ impl<'de, 'a> DeserializeSeed<'de> for DispatchEventWithTypeDeserializer<'a> {
             "INTEGRATION_UPDATE" => DispatchEvent::IntegrationUpdate(Box::new(
                 IntegrationUpdate::deserialize(deserializer)?,
             )),
-            "INTERACTION_CREATE" => DispatchEvent::InteractionCreate(Box::new(
-                InteractionCreate::deserialize(deserializer)?,
-            )),
+            "INTERACTION_CREATE" => {
+                DispatchEvent::InteractionCreate(InteractionCreate::deserialize(deserializer)?)
+            }
             "INVITE_CREATE" => {
                 DispatchEvent::InviteCreate(Box::new(InviteCreate::deserialize(deserializer)?))
             }
@@ -331,22 +329,22 @@ impl<'de, 'a> DeserializeSeed<'de> for DispatchEventWithTypeDeserializer<'a> {
                 DispatchEvent::StageInstanceUpdate(StageInstanceUpdate::deserialize(deserializer)?)
             }
             "THREAD_CREATE" => {
-                DispatchEvent::ThreadCreate(ThreadCreate::deserialize(deserializer)?)
+                DispatchEvent::ThreadCreate(Box::new(ThreadCreate::deserialize(deserializer)?))
             }
             "THREAD_DELETE" => {
                 DispatchEvent::ThreadDelete(ThreadDelete::deserialize(deserializer)?)
             }
             "THREAD_LIST_SYNC" => {
                 DispatchEvent::ThreadListSync(ThreadListSync::deserialize(deserializer)?)
             }
-            "THREAD_MEMBER_UPDATE" => {
-                DispatchEvent::ThreadMemberUpdate(ThreadMemberUpdate::deserialize(deserializer)?)
-            }
+            "THREAD_MEMBER_UPDATE" => DispatchEvent::ThreadMemberUpdate(Box::new(
+                ThreadMemberUpdate::deserialize(deserializer)?,
+            )),
             "THREAD_MEMBERS_UPDATE" => {
                 DispatchEvent::ThreadMembersUpdate(ThreadMembersUpdate::deserialize(deserializer)?)
             }
             "THREAD_UPDATE" => {
-                DispatchEvent::ThreadUpdate(ThreadUpdate::deserialize(deserializer)?)
+                DispatchEvent::ThreadUpdate(Box::new(ThreadUpdate::deserialize(deserializer)?))
             }
             "TYPING_START" => {
                 DispatchEvent::TypingStart(Box::new(TypingStart::deserialize(deserializer)?))

model/src/gateway/event/mod.rs

@@ -28,13 +28,13 @@ pub enum Event {
     /// A user's ban from a guild was removed.
     BanRemove(BanRemove),
     /// A channel was created.
-    ChannelCreate(ChannelCreate),
+    ChannelCreate(Box<ChannelCreate>),
     /// A channel was deleted.
-    ChannelDelete(ChannelDelete),
+    ChannelDelete(Box<ChannelDelete>),
     /// A channel's pins were updated.
     ChannelPinsUpdate(ChannelPinsUpdate),
     /// A channel was updated.
-    ChannelUpdate(ChannelUpdate),
+    ChannelUpdate(Box<ChannelUpdate>),
     /// A heartbeat was sent to or received from the gateway.
     GatewayHeartbeat(u64),
     /// A heartbeat acknowledgement was received from the gateway.
@@ -52,7 +52,7 @@ pub enum Event {
     /// A guild was created.
     GuildCreate(Box<GuildCreate>),
     /// A guild was deleted or the current user was removed from a guild.
-    GuildDelete(Box<GuildDelete>),
+    GuildDelete(GuildDelete),
     /// A guild's emojis were updated.
     GuildEmojisUpdate(GuildEmojisUpdate),
     /// A guild's integrations were updated.
@@ -66,7 +66,7 @@ pub enum Event {
     /// A guild integration was deleted.
     IntegrationUpdate(Box<IntegrationUpdate>),
     /// An interaction was invoked by a user.
-    InteractionCreate(Box<InteractionCreate>),
+    InteractionCreate(InteractionCreate),
     /// A invite was made.
     InviteCreate(Box<InviteCreate>),
     /// A invite was deleted.
@@ -137,17 +137,17 @@ pub enum Event {
     StageInstanceUpdate(StageInstanceUpdate),
     /// A thread has been created, relevant to the current user,
     /// or the current user has been added to a thread.
-    ThreadCreate(ThreadCreate),
+    ThreadCreate(Box<ThreadCreate>),
     /// A thread, relevant to the current user, has been deleted.
     ThreadDelete(ThreadDelete),
     /// The current user has gained access to a thread.
     ThreadListSync(ThreadListSync),
     /// The thread member object for the current user has been updated.
-    ThreadMemberUpdate(ThreadMemberUpdate),
+    ThreadMemberUpdate(Box<ThreadMemberUpdate>),
     /// A user has been added to or removed from a thread.
     ThreadMembersUpdate(ThreadMembersUpdate),
     /// A thread has been updated.
-    ThreadUpdate(ThreadUpdate),
+    ThreadUpdate(Box<ThreadUpdate>),
     /// A user started typing in a channel.
     TypingStart(Box<TypingStart>),
     /// A guild is now unavailable.
@@ -233,9 +233,9 @@ impl Event {
     }
 }
 
-impl From<Box<DispatchEvent>> for Event {
-    fn from(event: Box<DispatchEvent>) -> Self {
-        match *event {
+impl From<DispatchEvent> for Event {
+    fn from(event: DispatchEvent) -> Self {
+        match event {
             DispatchEvent::BanAdd(v) => Self::BanAdd(v),
             DispatchEvent::BanRemove(v) => Self::BanRemove(v),
             DispatchEvent::ChannelCreate(v) => Self::ChannelCreate(v),
@@ -295,7 +295,7 @@ impl From<Box<DispatchEvent>> for Event {
 impl From<GatewayEvent> for Event {
     fn from(event: GatewayEvent) -> Self {
         match event {
-            GatewayEvent::Dispatch(_, e) => Self::from(e),
+            GatewayEvent::Dispatch(_, e) => Self::from(*e),
             GatewayEvent::Heartbeat(interval) => Self::GatewayHeartbeat(interval),
             GatewayEvent::HeartbeatAck => Self::GatewayHeartbeatAck,
             GatewayEvent::Hello(interval) => Self::GatewayHello(interval),
@@ -349,3 +349,68 @@ impl Display for EventConversionError {
 }
 
 impl Error for EventConversionError {}
+
+#[cfg(test)]
+mod tests {
+    use super::{super::payload::incoming::*, shard::*, Event};
+    use static_assertions::const_assert_eq;
+    use std::mem;
+
+    const_assert_eq!(192, mem::size_of::<Event>());
+    const_assert_eq!(184, mem::size_of::<BanAdd>());
+    const_assert_eq!(184, mem::size_of::<BanRemove>());
+    const_assert_eq!(712, mem::size_of::<ChannelCreate>());
+    const_assert_eq!(712, mem::size_of::<ChannelDelete>());
+    const_assert_eq!(32, mem::size_of::<ChannelPinsUpdate>());
+    const_assert_eq!(712, mem::size_of::<ChannelUpdate>());
+    const_assert_eq!(16, mem::size_of::<Connected>());
+    const_assert_eq!(32, mem::size_of::<Connecting>());
+    const_assert_eq!(40, mem::size_of::<Disconnected>());
+    const_assert_eq!(632, mem::size_of::<GuildCreate>());
+    const_assert_eq!(16, mem::size_of::<GuildDelete>());
+    const_assert_eq!(32, mem::size_of::<GuildEmojisUpdate>());
+    const_assert_eq!(8, mem::size_of::<GuildIntegrationsUpdate>());
+    const_assert_eq!(400, mem::size_of::<GuildUpdate>());
+    const_assert_eq!(16, mem::size_of::<Identifying>());
+    const_assert_eq!(632, mem::size_of::<IntegrationCreate>());
+    const_assert_eq!(24, mem::size_of::<IntegrationDelete>());
+    const_assert_eq!(632, mem::size_of::<IntegrationUpdate>());
+    const_assert_eq!(16, mem::size_of::<InteractionCreate>());
+    const_assert_eq!(304, mem::size_of::<InviteCreate>());
+    const_assert_eq!(40, mem::size_of::<InviteDelete>());
+    const_assert_eq!(288, mem::size_of::<MemberAdd>());
+    const_assert_eq!(184, mem::size_of::<MemberRemove>());
+    const_assert_eq!(288, mem::size_of::<MemberUpdate>());
+    const_assert_eq!(112, mem::size_of::<MemberChunk>());
+    const_assert_eq!(1872, mem::size_of::<MessageCreate>());
+    const_assert_eq!(24, mem::size_of::<MessageDelete>());
+    const_assert_eq!(40, mem::size_of::<MessageDeleteBulk>());
+    const_assert_eq!(352, mem::size_of::<MessageUpdate>());
+    const_assert_eq!(24, mem::size_of::<Payload>());
+    const_assert_eq!(736, mem::size_of::<PresenceUpdate>());
+    const_assert_eq!(360, mem::size_of::<ReactionAdd>());
+    const_assert_eq!(360, mem::size_of::<ReactionRemove>());
+    const_assert_eq!(24, mem::size_of::<ReactionRemoveAll>());
+    const_assert_eq!(64, mem::size_of::<ReactionRemoveEmoji>());
+    const_assert_eq!(264, mem::size_of::<Ready>());
+    const_assert_eq!(8, mem::size_of::<Reconnecting>());
+    const_assert_eq!(16, mem::size_of::<Resuming>());
+    const_assert_eq!(128, mem::size_of::<RoleCreate>());
+    const_assert_eq!(16, mem::size_of::<RoleDelete>());
+    const_assert_eq!(128, mem::size_of::<RoleUpdate>());
+    const_assert_eq!(56, mem::size_of::<StageInstanceCreate>());
+    const_assert_eq!(56, mem::size_of::<StageInstanceDelete>());
+    const_assert_eq!(56, mem::size_of::<StageInstanceUpdate>());
+    const_assert_eq!(712, mem::size_of::<ThreadCreate>());
+    const_assert_eq!(32, mem::size_of::<ThreadDelete>());
+    const_assert_eq!(80, mem::size_of::<ThreadListSync>());
+    const_assert_eq!(552, mem::size_of::<ThreadMemberUpdate>());
+    const_assert_eq!(72, mem::size_of::<ThreadMembersUpdate>());
+    const_assert_eq!(712, mem::size_of::<ThreadUpdate>());
+    const_assert_eq!(320, mem::size_of::<TypingStart>());
+    const_assert_eq!(8, mem::size_of::<UnavailableGuild>());
+    const_assert_eq!(168, mem::size_of::<UserUpdate>());
+    const_assert_eq!(64, mem::size_of::<VoiceServerUpdate>());
+    const_assert_eq!(384, mem::size_of::<VoiceStateUpdate>());
+    const_assert_eq!(16, mem::size_of::<WebhooksUpdate>());
+}

standby/src/lib.rs

@@ -1606,8 +1606,8 @@ mod tests {
     /// the matching of a later event.
     #[tokio::test]
     async fn test_wait_for_component() {
-        let event = Event::InteractionCreate(Box::new(InteractionCreate(
-            Interaction::MessageComponent(Box::new(button())),
+        let event = Event::InteractionCreate(InteractionCreate(Interaction::MessageComponent(
+            Box::new(button()),
         )));
 
         let standby = Standby::new();
@@ -1630,20 +1630,20 @@ mod tests {
         let standby = Standby::new();
         let mut stream =
             standby.wait_for_component_stream(Id::new(3), |_: &MessageComponentInteraction| true);
-        standby.process(&Event::InteractionCreate(Box::new(InteractionCreate(
+        standby.process(&Event::InteractionCreate(InteractionCreate(
             Interaction::MessageComponent(Box::new(button())),
-        ))));
-        standby.process(&Event::InteractionCreate(Box::new(InteractionCreate(
+        )));
+        standby.process(&Event::InteractionCreate(InteractionCreate(
             Interaction::MessageComponent(Box::new(button())),
-        ))));
+        )));
 
         assert!(stream.next().await.is_some());
         assert!(stream.next().await.is_some());
         drop(stream);
         assert_eq!(1, standby.components.len());
-        standby.process(&Event::InteractionCreate(Box::new(InteractionCreate(
+        standby.process(&Event::InteractionCreate(InteractionCreate(
             Interaction::MessageComponent(Box::new(button())),
-        ))));
+        )));
         assert!(standby.components.is_empty());
     }