rustls/msgs/
macros.rs

1/// A macro which defines an enum type.
2macro_rules! enum_builder {
3    (
4    $(#[$comment:meta])*
5    @U8
6        EnumName: $enum_name: ident;
7        EnumVal { $( $enum_var: ident => $enum_val: expr ),* }
8    ) => {
9        $(#[$comment])*
10        #[non_exhaustive]
11        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
12        pub enum $enum_name {
13            $( $enum_var),*
14            ,Unknown(u8)
15        }
16        impl $enum_name {
17            pub fn get_u8(&self) -> u8 {
18                let x = self.clone();
19                match x {
20                    $( $enum_name::$enum_var => $enum_val),*
21                    ,$enum_name::Unknown(x) => x
22                }
23            }
24        }
25        impl Codec for $enum_name {
26            fn encode(&self, bytes: &mut Vec<u8>) {
27                self.get_u8().encode(bytes);
28            }
29
30            fn read(r: &mut Reader) -> Result<Self, crate::error::InvalidMessage> {
31                match u8::read(r) {
32                    Ok(x) => Ok($enum_name::from(x)),
33                    Err(_) => Err(crate::error::InvalidMessage::MissingData(stringify!($enum_name))),
34                }
35            }
36        }
37        impl From<u8> for $enum_name {
38            fn from(x: u8) -> Self {
39                match x {
40                    $($enum_val => $enum_name::$enum_var),*
41                    , x => $enum_name::Unknown(x),
42                }
43            }
44        }
45    };
46    (
47    $(#[$comment:meta])*
48    @U16
49        EnumName: $enum_name: ident;
50        EnumVal { $( $enum_var: ident => $enum_val: expr ),* }
51    ) => {
52        $(#[$comment])*
53        #[non_exhaustive]
54        #[derive(Debug, PartialEq, Eq, Clone, Copy)]
55        pub enum $enum_name {
56            $( $enum_var),*
57            ,Unknown(u16)
58        }
59        impl $enum_name {
60            pub fn get_u16(&self) -> u16 {
61                let x = self.clone();
62                match x {
63                    $( $enum_name::$enum_var => $enum_val),*
64                    ,$enum_name::Unknown(x) => x
65                }
66            }
67
68            pub fn as_str(&self) -> Option<&'static str> {
69                match self {
70                    $( $enum_name::$enum_var => Some(stringify!($enum_var))),*
71                    ,$enum_name::Unknown(_) => None,
72                }
73            }
74        }
75        impl Codec for $enum_name {
76            fn encode(&self, bytes: &mut Vec<u8>) {
77                self.get_u16().encode(bytes);
78            }
79
80            fn read(r: &mut Reader) -> Result<Self, crate::error::InvalidMessage> {
81                match u16::read(r) {
82                    Ok(x) => Ok($enum_name::from(x)),
83                    Err(_) => Err(crate::error::InvalidMessage::MissingData(stringify!($enum_name))),
84                }
85            }
86        }
87        impl From<u16> for $enum_name {
88            fn from(x: u16) -> Self {
89                match x {
90                    $($enum_val => $enum_name::$enum_var),*
91                    , x => $enum_name::Unknown(x),
92                }
93            }
94        }
95    };
96}