tlspuffin/tls/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        #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Deserialize, serde::Serialize, Hash, Extractable, Comparable, Ord, PartialOrd)]
11        #[extractable(TLSProtocolTypes)]
12        pub enum $enum_name {
13            $( $enum_var),*
14            ,Unknown(#[extractable_ignore] 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) -> Option<Self> {
31                u8::read(r).map($enum_name::from)
32            }
33        }
34        impl From<u8> for $enum_name {
35            fn from(x: u8) -> Self {
36                match x {
37                    $($enum_val => $enum_name::$enum_var),*
38                    , x => $enum_name::Unknown(x),
39                }
40            }
41        }
42    };
43    (
44    $(#[$comment:meta])*
45    @U16
46        EnumName: $enum_name: ident;
47        EnumVal { $( $enum_var: ident => $enum_val: expr ),* }
48    ) => {
49        $(#[$comment])*
50        #[derive(Debug, PartialEq, Eq, Clone, Copy, serde::Deserialize, serde::Serialize, Hash, Extractable, Comparable, Ord, PartialOrd)]
51        #[extractable(TLSProtocolTypes)]
52        pub enum $enum_name {
53            $( $enum_var),*
54            ,Unknown(#[extractable_ignore] u16)
55        }
56        impl $enum_name {
57            pub fn get_u16(&self) -> u16 {
58                let x = self.clone();
59                match x {
60                    $( $enum_name::$enum_var => $enum_val),*
61                    ,$enum_name::Unknown(x) => x
62                }
63            }
64
65            pub fn as_str(&self) -> Option<&'static str> {
66                match self {
67                    $( $enum_name::$enum_var => Some(stringify!($enum_var))),*
68                    ,$enum_name::Unknown(_) => None,
69                }
70            }
71        }
72        impl Codec for $enum_name {
73            fn encode(&self, bytes: &mut Vec<u8>) {
74                self.get_u16().encode(bytes);
75            }
76
77            fn read(r: &mut Reader) -> Option<Self> {
78                u16::read(r).map($enum_name::from)
79            }
80        }
81        impl From<u16> for $enum_name {
82            fn from(x: u16) -> Self {
83                match x {
84                    $($enum_val => $enum_name::$enum_var),*
85                    , x => $enum_name::Unknown(x),
86                }
87            }
88        }
89    };
90}