1macro_rules! open {
2 ($name: ident, $el_name: expr) => {
3 #[allow(dead_code)]
4 pub(crate) fn $name(mut self) -> Self {
5 self.writer
6 .write(XmlEvent::start_element($el_name))
7 .expect("should write to buf");
8 self
9 }
10 };
11 ($name: ident, $el_name: expr, $attr0: expr) => {
12 pub(crate) fn $name(mut self, arg0: &str) -> Self {
13 self.writer
14 .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
15 .expect("should write to buf");
16 self
17 }
18 };
19 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
20 pub(crate) fn $name(mut self, arg0: &str, arg1: &str) -> Self {
21 self.writer
22 .write(
23 XmlEvent::start_element($el_name)
24 .attr($attr0, arg0)
25 .attr($attr1, arg1),
26 )
27 .expect("should write to buf");
28 self
29 }
30 };
31 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
32 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str) -> Self {
33 self.writer
34 .write(
35 XmlEvent::start_element($el_name)
36 .attr($attr0, arg0)
37 .attr($attr1, arg1)
38 .attr($attr2, arg2),
39 )
40 .expect("should write to buf");
41 self
42 }
43 };
44 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr) => {
45 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, arg3: &str) -> Self {
46 self.writer
47 .write(
48 XmlEvent::start_element($el_name)
49 .attr($attr0, arg0)
50 .attr($attr1, arg1)
51 .attr($attr2, arg2)
52 .attr($attr3, arg3),
53 )
54 .expect("should write to buf");
55 self
56 }
57 };
58 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr) => {
59 pub(crate) fn $name(
60 mut self,
61 arg0: &str,
62 arg1: &str,
63 arg2: &str,
64 arg3: &str,
65 arg4: &str,
66 ) -> Self {
67 self.writer
68 .write(
69 XmlEvent::start_element($el_name)
70 .attr($attr0, arg0)
71 .attr($attr1, arg1)
72 .attr($attr2, arg2)
73 .attr($attr3, arg3)
74 .attr($attr4, arg4),
75 )
76 .expect("should write to buf");
77 self
78 }
79 };
80 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr) => {
81 pub(crate) fn $name(
82 mut self,
83 arg0: &str,
84 arg1: &str,
85 arg2: &str,
86 arg3: &str,
87 arg4: &str,
88 arg5: &str,
89 ) -> Self {
90 self.writer
91 .write(
92 XmlEvent::start_element($el_name)
93 .attr($attr0, arg0)
94 .attr($attr1, arg1)
95 .attr($attr2, arg2)
96 .attr($attr3, arg3)
97 .attr($attr4, arg4)
98 .attr($attr5, arg5),
99 )
100 .expect("should write to buf");
101 self
102 }
103 };
104 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr) => {
105 pub(crate) fn $name(
106 mut self,
107 arg0: &str,
108 arg1: &str,
109 arg2: &str,
110 arg3: &str,
111 arg4: &str,
112 arg5: &str,
113 arg6: &str,
114 ) -> Self {
115 self.writer
116 .write(
117 XmlEvent::start_element($el_name)
118 .attr($attr0, arg0)
119 .attr($attr1, arg1)
120 .attr($attr2, arg2)
121 .attr($attr3, arg3)
122 .attr($attr4, arg4)
123 .attr($attr5, arg5)
124 .attr($attr6, arg6),
125 )
126 .expect("should write to buf");
127 self
128 }
129 };
130 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr) => {
131 pub(crate) fn $name(
132 mut self,
133 arg0: &str,
134 arg1: &str,
135 arg2: &str,
136 arg3: &str,
137 arg4: &str,
138 arg5: &str,
139 arg6: &str,
140 arg7: &str,
141 ) -> Self {
142 self.writer
143 .write(
144 XmlEvent::start_element($el_name)
145 .attr($attr0, arg0)
146 .attr($attr1, arg1)
147 .attr($attr2, arg2)
148 .attr($attr3, arg3)
149 .attr($attr4, arg4)
150 .attr($attr5, arg5)
151 .attr($attr6, arg6)
152 .attr($attr7, arg7),
153 )
154 .expect("should write to buf");
155 self
156 }
157 };
158 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr, $attr8: expr) => {
159 pub(crate) fn $name(
160 mut self,
161 arg0: &str,
162 arg1: &str,
163 arg2: &str,
164 arg3: &str,
165 arg4: &str,
166 arg5: &str,
167 arg6: &str,
168 arg7: &str,
169 arg8: &str,
170 ) -> Self {
171 self.writer
172 .write(
173 XmlEvent::start_element($el_name)
174 .attr($attr0, arg0)
175 .attr($attr1, arg1)
176 .attr($attr2, arg2)
177 .attr($attr3, arg3)
178 .attr($attr4, arg4)
179 .attr($attr5, arg5)
180 .attr($attr6, arg6)
181 .attr($attr7, arg7)
182 .attr($attr8, arg8),
183 )
184 .expect("should write to buf");
185 self
186 }
187 };
188 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr, $attr8: expr, $attr9: expr) => {
189 #[allow(clippy::too_many_arguments)]
190 pub(crate) fn $name(
191 mut self,
192 arg0: &str,
193 arg1: &str,
194 arg2: &str,
195 arg3: &str,
196 arg4: &str,
197 arg5: &str,
198 arg6: &str,
199 arg7: &str,
200 arg8: &str,
201 arg9: &str,
202 ) -> Self {
203 self.writer
204 .write(
205 XmlEvent::start_element($el_name)
206 .attr($attr0, arg0)
207 .attr($attr1, arg1)
208 .attr($attr2, arg2)
209 .attr($attr3, arg3)
210 .attr($attr4, arg4)
211 .attr($attr5, arg5)
212 .attr($attr6, arg6)
213 .attr($attr7, arg7)
214 .attr($attr8, arg8)
215 .attr($attr9, arg9),
216 )
217 .expect("should write to buf");
218 self
219 }
220 };
221 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr, $attr8: expr, $attr9: expr, $attr10: expr) => {
222 pub(crate) fn $name(
223 mut self,
224 arg0: &str,
225 arg1: &str,
226 arg2: &str,
227 arg3: &str,
228 arg4: &str,
229 arg5: &str,
230 arg6: &str,
231 arg7: &str,
232 arg8: &str,
233 arg9: &str,
234 arg10: &str,
235 ) -> Self {
236 self.writer
237 .write(
238 XmlEvent::start_element($el_name)
239 .attr($attr0, arg0)
240 .attr($attr1, arg1)
241 .attr($attr2, arg2)
242 .attr($attr3, arg3)
243 .attr($attr4, arg4)
244 .attr($attr5, arg5)
245 .attr($attr6, arg6)
246 .attr($attr7, arg7)
247 .attr($attr8, arg8)
248 .attr($attr9, arg9)
249 .attr($attr10, arg10),
250 )
251 .expect("should write to buf");
252 self
253 }
254 };
255}
256
257macro_rules! closed_with_child {
258 ($name: ident, $el_name: expr) => {
259 #[allow(dead_code)]
260 pub(crate) fn $name(mut self, child: &str) -> Self {
261 self.writer
262 .write(XmlEvent::start_element($el_name))
263 .expect("should write to buf");
264 self.writer.write(child).expect("should write to buf");
265 self.close()
266 }
267 };
268 ($name: ident, $el_name: expr, $attr0: expr) => {
269 pub(crate) fn $name(mut self, arg0: &str, child: &str) -> Self {
270 self.writer
271 .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
272 .expect("should write to buf");
273 self.writer.write(child).expect("should write to buf");
274 self.close()
275 }
276 };
277 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
278 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, child: &str) -> Self {
279 self.writer
280 .write(
281 XmlEvent::start_element($el_name)
282 .attr($attr0, arg0)
283 .attr($attr1, arg1),
284 )
285 .expect("should write to buf");
286 self.writer.write(child).expect("should write to buf");
287 self.close()
288 }
289 };
290 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
291 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, child: &str) -> Self {
292 self.writer
293 .write(
294 XmlEvent::start_element($el_name)
295 .attr($attr0, arg0)
296 .attr($attr1, arg1)
297 .attr($attr2, arg2),
298 )
299 .expect("should write to buf");
300 self.writer.write(child).expect("should write to buf");
301 self.close()
302 }
303 };
304}
305
306macro_rules! closed {
307 ($name: ident, $el_name: expr) => {
308 #[allow(clippy::wrong_self_convention)]
309 pub(crate) fn $name(mut self) -> Self {
310 self.writer
311 .write(XmlEvent::start_element($el_name))
312 .expect("should write to buf");
313 self.close()
314 }
315 };
316 ($name: ident, $el_name: expr, $attr0: expr) => {
317 #[allow(clippy::wrong_self_convention)]
318
319 pub(crate) fn $name(mut self, arg0: &str) -> Self {
320 self.writer
321 .write(XmlEvent::start_element($el_name).attr($attr0, arg0))
322 .expect("should write to buf");
323 self.close()
324 }
325 };
326 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr) => {
327 #[allow(dead_code)]
328 #[allow(clippy::wrong_self_convention)]
329 pub(crate) fn $name(mut self, arg0: &str, arg1: &str) -> Self {
330 self.writer
331 .write(
332 XmlEvent::start_element($el_name)
333 .attr($attr0, arg0)
334 .attr($attr1, arg1),
335 )
336 .expect("should write to buf");
337 self.close()
338 }
339 };
340 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr) => {
341 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str) -> Self {
342 self.writer
343 .write(
344 XmlEvent::start_element($el_name)
345 .attr($attr0, arg0)
346 .attr($attr1, arg1)
347 .attr($attr2, arg2),
348 )
349 .expect("should write to buf");
350 self.close()
351 }
352 };
353 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr) => {
354 pub(crate) fn $name(mut self, arg0: &str, arg1: &str, arg2: &str, arg3: &str) -> Self {
355 self.writer
356 .write(
357 XmlEvent::start_element($el_name)
358 .attr($attr0, arg0)
359 .attr($attr1, arg1)
360 .attr($attr2, arg2)
361 .attr($attr3, arg3),
362 )
363 .expect("should write to buf");
364 self.close()
365 }
366 };
367 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr) => {
368 pub(crate) fn $name(
369 mut self,
370 arg0: &str,
371 arg1: &str,
372 arg2: &str,
373 arg3: &str,
374 arg4: &str,
375 ) -> Self {
376 self.writer
377 .write(
378 XmlEvent::start_element($el_name)
379 .attr($attr0, arg0)
380 .attr($attr1, arg1)
381 .attr($attr2, arg2)
382 .attr($attr3, arg3)
383 .attr($attr4, arg4),
384 )
385 .expect("should write to buf");
386 self.close()
387 }
388 };
389 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr) => {
390 pub(crate) fn $name(
391 mut self,
392 arg0: &str,
393 arg1: &str,
394 arg2: &str,
395 arg3: &str,
396 arg4: &str,
397 arg5: &str,
398 ) -> Self {
399 self.writer
400 .write(
401 XmlEvent::start_element($el_name)
402 .attr($attr0, arg0)
403 .attr($attr1, arg1)
404 .attr($attr2, arg2)
405 .attr($attr3, arg3)
406 .attr($attr4, arg4)
407 .attr($attr5, arg5),
408 )
409 .expect("should write to buf");
410 self.close()
411 }
412 };
413 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr) => {
414 #[allow(clippy::too_many_arguments)]
415 pub(crate) fn $name(
416 mut self,
417 arg0: &str,
418 arg1: &str,
419 arg2: &str,
420 arg3: &str,
421 arg4: &str,
422 arg5: &str,
423 arg6: &str,
424 ) -> Self {
425 self.writer
426 .write(
427 XmlEvent::start_element($el_name)
428 .attr($attr0, arg0)
429 .attr($attr1, arg1)
430 .attr($attr2, arg2)
431 .attr($attr3, arg3)
432 .attr($attr4, arg4)
433 .attr($attr5, arg5)
434 .attr($attr6, arg6),
435 )
436 .expect("should write to buf");
437 self.close()
438 }
439 };
440 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr) => {
441 #[allow(clippy::too_many_arguments)]
442 pub(crate) fn $name(
443 mut self,
444 arg0: &str,
445 arg1: &str,
446 arg2: &str,
447 arg3: &str,
448 arg4: &str,
449 arg5: &str,
450 arg6: &str,
451 arg7: &str,
452 ) -> Self {
453 self.writer
454 .write(
455 XmlEvent::start_element($el_name)
456 .attr($attr0, arg0)
457 .attr($attr1, arg1)
458 .attr($attr2, arg2)
459 .attr($attr3, arg3)
460 .attr($attr4, arg4)
461 .attr($attr5, arg5)
462 .attr($attr6, arg6)
463 .attr($attr7, arg7),
464 )
465 .expect("should write to buf");
466 self.close()
467 }
468 };
469 ($name: ident, $el_name: expr, $attr0: expr, $attr1: expr, $attr2: expr, $attr3: expr, $attr4: expr, $attr5: expr, $attr6: expr, $attr7: expr, $attr8: expr) => {
470 #[allow(clippy::too_many_arguments)]
471 pub(crate) fn $name(
472 mut self,
473 arg0: &str,
474 arg1: &str,
475 arg2: &str,
476 arg3: &str,
477 arg4: &str,
478 arg5: &str,
479 arg6: &str,
480 arg7: &str,
481 arg8: &str,
482 ) -> Self {
483 self.writer
484 .write(
485 XmlEvent::start_element($el_name)
486 .attr($attr0, arg0)
487 .attr($attr1, arg1)
488 .attr($attr2, arg2)
489 .attr($attr3, arg3)
490 .attr($attr4, arg4)
491 .attr($attr5, arg5)
492 .attr($attr6, arg6)
493 .attr($attr7, arg7)
494 .attr($attr8, arg8),
495 )
496 .expect("should write to buf");
497 self.close()
498 }
499 };
500}
501
502macro_rules! closed_with_str {
503 ($name: ident, $el_name: expr) => {
504 #[allow(dead_code)]
505 pub(crate) fn $name(mut self, val: &str) -> Self {
506 self.writer
507 .write(XmlEvent::start_element($el_name).attr("w:val", val))
508 .expect("should write to buf");
509 self.close()
510 }
511 };
512}
513
514macro_rules! closed_with_usize {
515 ($name: ident, $el_name: expr) => {
516 pub(crate) fn $name(mut self, val: usize) -> Self {
517 self.writer
518 .write(XmlEvent::start_element($el_name).attr("w:val", &format!("{}", val)))
519 .expect("should write to buf");
520 self.close()
521 }
522 };
523}
524
525macro_rules! closed_with_isize {
526 ($name: ident, $el_name: expr) => {
527 pub(crate) fn $name(mut self, val: isize) -> Self {
528 self.writer
529 .write(XmlEvent::start_element($el_name).attr("w:val", &format!("{}", val)))
530 .expect("should write to buf");
531 self.close()
532 }
533 };
534}
535
536macro_rules! closed_w_with_type_el {
537 ($name: ident, $el_name: expr) => {
538 pub(crate) fn $name(mut self, w: i32, t: WidthType) -> Self {
539 self.writer
540 .write(
541 XmlEvent::start_element($el_name)
542 .attr("w:w", &format!("{}", w))
543 .attr("w:type", &t.to_string()),
544 )
545 .expect(EXPECT_MESSAGE);
546 self.close()
547 }
548 };
549}
550
551macro_rules! closed_border_el {
552 ($name: ident, $el_name: expr) => {
553 pub(crate) fn $name(
554 mut self,
555 val: BorderType,
556 size: usize,
557 space: usize,
558 color: &str,
559 ) -> Self {
560 self.writer
561 .write(
562 XmlEvent::start_element($el_name)
563 .attr("w:val", &val.to_string())
564 .attr("w:sz", &format!("{}", size))
565 .attr("w:space", &format!("{}", space))
566 .attr("w:color", color),
567 )
568 .expect(EXPECT_MESSAGE);
569 self.close()
570 }
571 };
572}
573
574macro_rules! closed_paragraph_border_el {
575 ($name: ident, $ el_name: expr) => {
576 pub(crate) fn $name<'a>(mut self, val: &str, space: &str, size: &str, color: &str) -> Self {
577 self.writer
578 .write(
579 XmlEvent::start_element($el_name)
580 .attr("w:val", val)
581 .attr("w:space", space)
582 .attr("w:sz", size)
583 .attr("w:color", color),
584 )
585 .expect(EXPECT_MESSAGE);
586 self.close()
587 }
588 };
589}