twilight_model/channel/
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 ChannelFlags: u64 {
10        /// Channel is pinned in a forum.
11        const PINNED = 1 << 1;
12        /// New threads in a forum channel require a tag.
13        const REQUIRE_TAG = 1 << 4;
14    }
15}
16
17impl<'de> Deserialize<'de> for ChannelFlags {
18    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
19        Ok(Self::from_bits_truncate(u64::deserialize(deserializer)?))
20    }
21}
22
23impl Serialize for ChannelFlags {
24    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
25    where
26        S: Serializer,
27    {
28        serializer.serialize_u64(self.bits())
29    }
30}
31
32#[cfg(test)]
33mod tests {
34    use super::ChannelFlags;
35    use serde::{Deserialize, Serialize};
36    use serde_test::Token;
37    use static_assertions::{assert_impl_all, const_assert_eq};
38    use std::{
39        fmt::{Binary, Debug, LowerHex, Octal, UpperHex},
40        hash::Hash,
41        ops::{
42            BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Sub, SubAssign,
43        },
44    };
45
46    assert_impl_all!(
47        ChannelFlags: Binary,
48        BitAnd,
49        BitAndAssign,
50        BitOr,
51        BitOrAssign,
52        BitXor,
53        BitXorAssign,
54        Clone,
55        Copy,
56        Debug,
57        Deserialize<'static>,
58        Eq,
59        Extend<ChannelFlags>,
60        FromIterator<ChannelFlags>,
61        Hash,
62        LowerHex,
63        Not,
64        Octal,
65        PartialEq,
66        Send,
67        Serialize,
68        Sub,
69        SubAssign,
70        Sync,
71        UpperHex
72    );
73    const_assert_eq!(ChannelFlags::PINNED.bits(), 1 << 1);
74    const_assert_eq!(ChannelFlags::REQUIRE_TAG.bits(), 1 << 4);
75
76    #[test]
77    fn serde() {
78        serde_test::assert_tokens(
79            &ChannelFlags::PINNED,
80            &[Token::U64(ChannelFlags::PINNED.bits())],
81        );
82        // Deserialization truncates unknown bits.
83        serde_test::assert_de_tokens(&ChannelFlags::empty(), &[Token::U64(1 << 63)]);
84    }
85}