netlink_rust/core/
helpers.rs

1
2/// Creates an enum with various traits. 
3/// The first key-value pair is the default used if any conversion would fail.
4#[macro_export]
5macro_rules! extended_enum_default {
6    ( $name:ident, $ty:ty, $var_def:ident => $val_def:expr,
7      $( $var:ident => $val:expr ),+ $(,)* ) => (
8        
9        #[derive(Clone,Debug,Eq,PartialEq)]
10        pub enum $name {
11            $var_def,
12            $($var,)*
13        }
14
15        impl From<$ty> for $name {
16            fn from(v: $ty) -> Self {
17                match v {
18                    $val_def => $name::$var_def,
19                    $( $val => $name::$var,)*
20                    _ => $name::$var_def,
21                }
22            }
23        }
24
25        impl From<$name> for $ty {
26            fn from(v: $name) -> Self {
27                match v {
28                    $name::$var_def => $val_def,
29                    $( $name::$var => $val, )*
30                }
31            }
32        }
33
34        impl ConvertFrom<$ty> for $name {
35            fn convert_from(v: $ty) -> Option<Self> {
36                match v {
37                    $val_def => Some($name::$var_def),
38                    $( $val => Some($name::$var),)*
39                    _ => None,
40                }
41            }
42        }
43
44        impl PartialEq<$name> for $ty {
45            fn eq(&self, other: &$name) -> bool {
46                match *other {
47                    $name::$var_def => *self == $val_def,
48                    $( $name::$var => *self == $val, )*
49                }
50            }
51
52            fn ne(&self, other: &$name) -> bool {
53                match *other {
54                    $name::$var_def => *self != $val_def,
55                    $( $name::$var => *self != $val, )*
56                }
57            }
58        }
59    );
60}
61
62/// Creates an enum with various traits. 
63/// The first key-value pair is the default used if any conversion would fail.
64#[macro_export]
65macro_rules! extended_enum {
66    ( $name:ident, $ty:ty, $( $var:ident => $val:expr ),+ $(,)* ) => (
67        
68        #[derive(Clone,Debug,Eq,PartialEq)]
69        pub enum $name {
70            $($var,)*
71        }
72
73        impl From<$ty> for $name {
74            fn from(v: $ty) -> Self {
75                match v {
76                    $( $val => $name::$var,)*
77                    _ => panic!("Bad Value"),
78                }
79            }
80        }
81
82        impl From<$name> for $ty {
83            fn from(v: $name) -> Self {
84                match v {
85                    $( $name::$var => $val, )*
86                }
87            }
88        }
89
90        impl ConvertFrom<$ty> for $name {
91            fn convert_from(v: $ty) -> Option<Self> {
92                match v {
93                    $( $val => Some($name::$var),)*
94                    _ => None,
95                }
96            }
97        }
98
99        impl PartialEq<$name> for $ty {
100            fn eq(&self, other: &$name) -> bool {
101                match *other {
102                    $( $name::$var => *self == $val, )*
103                }
104            }
105
106            fn ne(&self, other: &$name) -> bool {
107                match *other {
108                    $( $name::$var => *self != $val, )*
109                }
110            }
111        }
112    );
113}