discord_webhook2/message/
flags.rs

1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2
3#[derive(Debug, Clone)]
4pub struct MessageFlags {
5    /// This message has been published to subscribed channels (via Channel Following)
6    crossposted: bool,
7    /// This message originated from a message in another channel (via Channel Following)
8    is_crosspost: bool,
9    /// Do not include any embeds when serializing this message
10    suppress_embeds: bool,
11    /// The source message for this crosspost has been deleted (via Channel Following)
12    source_message_deleted: bool,
13    /// This message came from the urgent message system
14    urgent: bool,
15    /// This message has an associated thread, with the same id as the message
16    has_thread: bool,
17    /// This message is only visible to the user who invoked the Interaction
18    ephemeral: bool,
19    /// This message is an Interaction Response and the bot is "thinking"
20    loading: bool,
21    /// This message failed to mention some roles and add their members to the thread
22    failed_to_mention_some_roles_in_thread: bool,
23    /// This message will not trigger push and desktop notifications
24    suppress_notifications: bool,
25    /// This message is a voice message
26    is_voice_message: bool,
27}
28
29macro_rules! set_bit {
30    ($v:expr, $bit:expr) => {
31        $v |= 1 << $bit;
32    };
33}
34
35impl Serialize for MessageFlags {
36    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
37    where
38        S: Serializer,
39    {
40        let mut bitfield = 0;
41
42        if self.crossposted {
43            set_bit!(bitfield, 0);
44        };
45        if self.is_crosspost {
46            set_bit!(bitfield, 1);
47        };
48        if self.suppress_embeds {
49            set_bit!(bitfield, 2);
50        };
51        if self.source_message_deleted {
52            set_bit!(bitfield, 3);
53        };
54        if self.urgent {
55            set_bit!(bitfield, 4);
56        };
57        if self.has_thread {
58            set_bit!(bitfield, 5);
59        };
60        if self.ephemeral {
61            set_bit!(bitfield, 6);
62        };
63        if self.loading {
64            set_bit!(bitfield, 7);
65        };
66        if self.failed_to_mention_some_roles_in_thread {
67            set_bit!(bitfield, 8);
68        };
69        if self.suppress_notifications {
70            set_bit!(bitfield, 12);
71        };
72        if self.is_voice_message {
73            set_bit!(bitfield, 13);
74        };
75
76        serializer.serialize_u16(bitfield)
77    }
78}
79
80macro_rules! get_bit {
81    ($v:expr, $bit:expr) => {
82        ($v >> $bit) & 1 != 0
83    };
84}
85
86impl<'de> Deserialize<'de> for MessageFlags {
87    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
88    where
89        D: Deserializer<'de>,
90    {
91        let bitfield = u16::deserialize(deserializer)?;
92
93        Ok(Self {
94            crossposted: get_bit!(bitfield, 0),
95            is_crosspost: get_bit!(bitfield, 1),
96            suppress_embeds: get_bit!(bitfield, 2),
97            source_message_deleted: get_bit!(bitfield, 3),
98            urgent: get_bit!(bitfield, 4),
99            has_thread: get_bit!(bitfield, 5),
100            ephemeral: get_bit!(bitfield, 6),
101            loading: get_bit!(bitfield, 7),
102            failed_to_mention_some_roles_in_thread: get_bit!(bitfield, 8),
103            suppress_notifications: get_bit!(bitfield, 12),
104            is_voice_message: get_bit!(bitfield, 13),
105        })
106    }
107}