cqc 0.6.1

An implementation of the CQC interface.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

// ----------------------------------------------------------------------------
// Define length utilities for headers.
// ----------------------------------------------------------------------------
macro_rules! def_len {
    ($hdr_name: ident, $value: expr) => {
        impl $hdr_name {
            #[inline]
            pub fn hdr_len() -> u32 {
                $value
            }
            #[inline]
            pub fn len(&self) -> u32 {
                $value
            }
        }
    }
}

// ----------------------------------------------------------------------------
// Define set flag functions for bitflag types.
// ----------------------------------------------------------------------------
macro_rules! def_set_flag {
    ($opt_name: ident, $flag: ident, $fn_name: ident) => {
        #[inline]
        pub fn $fn_name(&mut self) -> &mut $opt_name {
            self.insert($opt_name::$flag);
            self
        }
    }
}

// ----------------------------------------------------------------------------
// Define get flag functions for bitflag types.
// ----------------------------------------------------------------------------
macro_rules! def_get_flag {
    ($opt_name: ident, $flag: ident, $fn_name: ident) => {
        #[inline]
        pub fn $fn_name(&self) -> bool {
            self.contains($opt_name::$flag)
        }
    }
}

// ----------------------------------------------------------------------------
// Implement the Serialize and Deserialize traits on a bitflag option.
// ----------------------------------------------------------------------------
macro_rules! serde_option_u8 {
    ($opt_name: ident, $visitor_name: ident, $str_name: expr) => {
        impl Serialize for $opt_name {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                serializer.serialize_u8(self.bits())
            }
        }

        struct $visitor_name;

        impl<'de> Visitor<'de> for $visitor_name {
            type Value = $opt_name;

            #[inline]
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str(&format!("valid 8-bit CQC {} options", $str_name))
            }

            #[inline]
            fn visit_u8<E>(self, value: u8) -> Result<$opt_name, E>
            where
                E: de::Error,
            {
                Ok($opt_name::from_bits_truncate(value))
            }
        }

        impl<'de> Deserialize<'de> for $opt_name {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<$opt_name, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_u8($visitor_name)
            }
        }
    }
}

// ----------------------------------------------------------------------------
// Implement the Serialize trait on a u8 enum.
// ----------------------------------------------------------------------------
macro_rules! serialize_enum_u8 {
    ($enum_name: ident) => {
        impl Serialize for $enum_name {
            #[inline]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                serializer.serialize_u8(*self as u8)
            }
        }
    }
}

// ----------------------------------------------------------------------------
// Implement the Deserialize trait on a u8 enum.
// ----------------------------------------------------------------------------
macro_rules! deserialize_enum_u8 {
    ($enum_name: ident, $visitor_name: ident, $str_name: expr) => {
        struct $visitor_name;

        impl<'de> Visitor<'de> for $visitor_name {
            type Value = $enum_name;

            #[inline]
            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str(&format!("a valid {}", $str_name))
            }

            #[inline]
            fn visit_u8<E>(self, value: u8) -> Result<$enum_name, E>
            where
                E: de::Error,
            {
                let instr = match $enum_name::get(value) {
                    Some(x) => x,
                    None => {
                        return Err(E::custom(
                            format!("Invalid {}: {}", $str_name, value),
                        ))
                    }
                };

                Ok(instr)
            }
        }

        impl<'de> Deserialize<'de> for $enum_name {
            #[inline]
            fn deserialize<D>(deserializer: D) -> Result<$enum_name, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_u8($visitor_name)
            }
        }
    }
}

// ----------------------------------------------------------------------------
// Implement the Serialize and Deserialize traits on a u8 enum.
// ----------------------------------------------------------------------------
macro_rules! serde_enum_u8 {
    ($enum_name: ident, $visitor_name: ident, $str_name: expr) => {
        serialize_enum_u8!($enum_name);
        deserialize_enum_u8!($enum_name, $visitor_name, $str_name);
    }
}