docx_rust/
macros.rs

1#[macro_export]
2#[doc(hidden)]
3macro_rules! __define_struct_vec {
4    ( ($tag:expr, $name:ident, $choicename:ident) { $($value2:expr, $variant2:ident, $ty2: ty)* } { $($value:expr, $variant:ident)* }) => {
5        #[derive(Debug, XmlRead, XmlWrite, Clone)]
6        #[cfg_attr(test, derive(PartialEq))]
7        pub enum $choicename {
8            $(
9                #[xml(tag = $value)]
10                $variant($variant),
11            )*
12        }
13
14        #[derive(Debug, Default, XmlRead, XmlWrite, Clone)]
15        #[cfg_attr(test, derive(PartialEq))]
16        #[xml(tag = $tag)]
17        pub struct $name {
18            $(
19                #[xml(attr = $value2)]
20                pub $variant2: Option<$ty2>,
21            )*
22
23            #[xml(
24                $(
25                    child = $value,
26                )*
27            )]
28            pub content: Vec<$choicename>,
29        }
30
31        impl $name {
32            $(
33                #[inline(always)]
34                pub fn $variant2<T: Into<$ty2>>(mut self, value: T) -> Self {
35                    self.$variant2 = Some(value.into());
36                    self
37                }
38            )*
39        }
40    }
41}
42
43#[macro_export]
44#[doc(hidden)]
45macro_rules! __define_struct {
46    ( ($tag:expr, $name:ident, $a:lifetime) { $($value:expr, $variant:ident, $ty: ty)* }) => {
47        #[derive(Debug, XmlRead, XmlWrite, Clone, Default)]
48        #[cfg_attr(test, derive(PartialEq))]
49        #[xml(tag = $tag)]
50        pub struct $name<$a> {
51            $(
52                #[xml(attr = $value)]
53                pub $variant: Option<$ty>,
54            )*
55        }
56
57        impl<$a> $name<$a> {
58            $(
59                #[inline(always)]
60                pub fn $variant<T: Into<$ty>>(mut self, value: T) -> Self {
61                    self.$variant = Some(value.into());
62                    self
63                }
64            )*
65        }
66    };
67
68    ( ($tag:expr, $name:ident) { $($value:expr, $variant:ident, $ty: ty)* }) => {
69        #[derive(Debug, XmlRead, XmlWrite, Clone, Default)]
70        #[cfg_attr(test, derive(PartialEq))]
71        #[xml(tag = $tag)]
72        pub struct $name {
73            $(
74                #[xml(attr = $value)]
75                pub $variant: Option<$ty>,
76            )*
77        }
78
79        impl $name {
80            $(
81                #[inline(always)]
82                pub fn $variant<T: Into<$ty>>(mut self, value: T) -> Self {
83                    self.$variant = Some(value.into());
84                    self
85                }
86            )*
87        }
88    };
89
90    ( ($tag:expr, $name:ident) { $($value:expr, $variant:ident, $ty: ty)* } { $($value2:expr, $variant2:ident, $ty2: ty)* }) => {
91        #[derive(Debug, XmlRead, XmlWrite, Clone, Default)]
92        #[cfg_attr(test, derive(PartialEq))]
93        #[xml(tag = $tag)]
94        pub struct $name {
95            $(
96                #[xml(attr = $value)]
97                pub $variant: Option<$ty>,
98            )*
99            $(
100                #[xml(child = $value2)]
101                pub $variant2: Option<$ty2>,
102            )*
103        }
104
105        impl $name {
106            $(
107                #[inline(always)]
108                pub fn $variant<T: Into<$ty>>(mut self, value: T) -> Self {
109                    self.$variant = Some(value.into());
110                    self
111                }
112            )*
113
114            $(
115                #[inline(always)]
116                pub fn $variant2<T: Into<$ty2>>(mut self, value: T) -> Self {
117                    self.$variant2 = Some(value.into());
118                    self
119                }
120            )*
121        }
122    };
123}
124
125#[macro_export]
126#[doc(hidden)]
127macro_rules! __define_enum {
128    ($name:ident { $($variant:ident = $value:expr, )* }) => {
129        #[derive(Debug, Clone)]
130        #[cfg_attr(test, derive(PartialEq))]
131        pub enum $name {
132            $( $variant, )*
133        }
134
135        impl std::fmt::Display for $name {
136            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
137                match *self {
138                    $( $name::$variant => write!(f, $value), )*
139                }
140            }
141        }
142
143        impl std::str::FromStr for $name {
144            type Err = String;
145
146            fn from_str(s: &str) -> Result<Self, Self::Err> {
147                match s {
148                    $($value => Ok($name::$variant),)*
149                    s => Err(format!(
150                        "Unkown Value. Found `{}`, Expected `{}`",
151                        s,
152                        stringify!($($value,)*)
153                    ))
154                }
155            }
156        }
157    }
158}
159
160#[macro_export]
161#[doc(hidden)]
162macro_rules! __string_enum {
163    ($name:ident { $($variant:ident = $value:expr, )* }) => {
164        impl std::fmt::Display for $name {
165            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
166                match *self {
167                    $( $name::$variant => write!(f, $value), )*
168                }
169            }
170        }
171
172        impl std::str::FromStr for $name {
173            type Err = String;
174
175            fn from_str(s: &str) -> Result<Self, Self::Err> {
176                match s {
177                    $($value => Ok($name::$variant),)*
178                    s => Err(format!(
179                        "Unkown Value. Found `{}`, Expected `{}`",
180                        s,
181                        stringify!($($value,)*)
182                    ))
183                }
184            }
185        }
186    }
187}
188
189#[macro_export]
190#[doc(hidden)]
191macro_rules! __setter {
192    ($field:ident: Option<$ty:ty>) => {
193        #[inline(always)]
194        pub fn $field<T: Into<$ty>>(mut self, value: T) -> Self {
195            self.$field = Some(value.into());
196            self
197        }
198    };
199    ($field:ident: $ty:ty) => {
200        #[inline(always)]
201        pub fn $field<T: Into<$ty>>(mut self, value: T) -> Self {
202            self.$field = value.into();
203            self
204        }
205    };
206}
207
208#[macro_export]
209#[doc(hidden)]
210macro_rules! __xml_test_suites {
211    ($type:tt, $($struct:expr, $string:expr,)*) => {
212        #[test]
213        fn xml_test_suites() -> hard_xml::XmlResult<()> {
214            let _ = env_logger::builder()
215                .is_test(true)
216                .format_timestamp(None)
217                .try_init();
218
219            $(
220                assert_eq!($string, ($struct).to_string()?);
221                assert_eq!($struct, $type::from_str($string)?);
222            )*
223
224            Ok(())
225        }
226    };
227}
docx_rust/macros.rs

docx_rust/
macros.rs
