Skip to main content

twilight_model/user/
flags.rs

1use bitflags::bitflags;
2use serde::{
3    de::{Deserialize, Deserializer},
4    ser::{Serialize, Serializer},
5};
6
7bitflags! {
8    #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
9    pub struct UserFlags: u64 {
10        /// Discord Employee.
11        const STAFF = 1;
12        /// Partnered server owner.
13        const PARTNER = 1 << 1;
14        /// HypeSquad events member.
15        const HYPESQUAD = 1 << 2;
16        /// Bug hunter level 1.
17        const BUG_HUNTER_LEVEL_1 = 1 << 3;
18        /// House Bravery member.
19        const HYPESQUAD_ONLINE_HOUSE_1 = 1 << 6;
20        /// House Brilliance member.
21        const HYPESQUAD_ONLINE_HOUSE_2 = 1 << 7;
22        /// House Balance member.
23        const HYPESQUAD_ONLINE_HOUSE_3 = 1 << 8;
24        /// Early Nitro supporter.
25        const PREMIUM_EARLY_SUPPORTER = 1 << 9;
26        /// User is in a team.
27        const TEAM_PSEUDO_USER = 1 << 10;
28        /// Bug hunter level 2.
29        const BUG_HUNTER_LEVEL_2 = 1 << 14;
30        /// Verified bot.
31        const VERIFIED_BOT = 1 << 16;
32        /// Early verified bot developer.
33        const VERIFIED_DEVELOPER = 1 << 17;
34        /// Moderator Programs Alumni
35        #[deprecated(since = "0.17.2", note = "renamed to CERTIFIED_MODERATOR")]
36        #[doc(hidden)]
37        const MODERATOR_PROGRAMS_ALUMNI = 1 << 18;
38        /// Moderator Programs Alumni
39        const CERTIFIED_MODERATOR = 1 << 18;
40        /// Bot uses only HTTP interactions and is shown in the online member
41        /// list.
42        const BOT_HTTP_INTERACTIONS = 1 << 19;
43        /// User is an [Active Developer].
44        ///
45        /// [Active Developer]: https://support-dev.discord.com/hc/articles/10113997751447
46        const ACTIVE_DEVELOPER = 1 << 22;
47    }
48}
49
50impl<'de> Deserialize<'de> for UserFlags {
51    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
52        Ok(Self::from_bits_truncate(u64::deserialize(deserializer)?))
53    }
54}
55
56impl Serialize for UserFlags {
57    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
58    where
59        S: Serializer,
60    {
61        serializer.serialize_u64(self.bits())
62    }
63}
64
65#[cfg(test)]
66mod tests {
67    #![allow(deprecated)]
68
69    use super::UserFlags;
70    use serde::{Deserialize, Serialize};
71    use serde_test::Token;
72    use static_assertions::{assert_impl_all, const_assert_eq};
73    use std::{
74        fmt::{Binary, Debug, LowerHex, Octal, UpperHex},
75        hash::Hash,
76        ops::{
77            BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Sub, SubAssign,
78        },
79    };
80
81    assert_impl_all!(
82        UserFlags: Binary,
83        BitAnd,
84        BitAndAssign,
85        BitOr,
86        BitOrAssign,
87        BitXor,
88        BitXorAssign,
89        Clone,
90        Copy,
91        Debug,
92        Deserialize<'static>,
93        Eq,
94        Extend<UserFlags>,
95        FromIterator<UserFlags>,
96        Hash,
97        LowerHex,
98        Not,
99        Octal,
100        PartialEq,
101        Send,
102        Serialize,
103        Sub,
104        SubAssign,
105        Sync,
106        UpperHex
107    );
108
109    const_assert_eq!(UserFlags::STAFF.bits(), 1);
110    const_assert_eq!(UserFlags::PARTNER.bits(), 1 << 1);
111    const_assert_eq!(UserFlags::HYPESQUAD.bits(), 1 << 2);
112    const_assert_eq!(UserFlags::BUG_HUNTER_LEVEL_1.bits(), 1 << 3);
113    const_assert_eq!(UserFlags::HYPESQUAD_ONLINE_HOUSE_1.bits(), 1 << 6);
114    const_assert_eq!(UserFlags::HYPESQUAD_ONLINE_HOUSE_2.bits(), 1 << 7);
115    const_assert_eq!(UserFlags::HYPESQUAD_ONLINE_HOUSE_3.bits(), 1 << 8);
116    const_assert_eq!(UserFlags::PREMIUM_EARLY_SUPPORTER.bits(), 1 << 9);
117    const_assert_eq!(UserFlags::TEAM_PSEUDO_USER.bits(), 1 << 10);
118    const_assert_eq!(UserFlags::BUG_HUNTER_LEVEL_2.bits(), 1 << 14);
119    const_assert_eq!(UserFlags::VERIFIED_BOT.bits(), 1 << 16);
120    const_assert_eq!(UserFlags::VERIFIED_DEVELOPER.bits(), 1 << 17);
121    const_assert_eq!(UserFlags::MODERATOR_PROGRAMS_ALUMNI.bits(), 1 << 18);
122    const_assert_eq!(UserFlags::CERTIFIED_MODERATOR.bits(), 1 << 18);
123    const_assert_eq!(UserFlags::BOT_HTTP_INTERACTIONS.bits(), 1 << 19);
124    const_assert_eq!(UserFlags::ACTIVE_DEVELOPER.bits(), 1 << 22);
125
126    #[test]
127    fn serde() {
128        serde_test::assert_tokens(
129            &UserFlags::PARTNER,
130            &[Token::U64(UserFlags::PARTNER.bits())],
131        );
132        // Deserialization truncates unknown bits.
133        serde_test::assert_de_tokens(&UserFlags::empty(), &[Token::U64(1 << 63)]);
134    }
135}