serde_xml_rs/ser/
tuple.rs

1use std::io::Write;
2
3use serde::ser::Serialize;
4
5use super::Serializer;
6use crate::error::{Error, Result};
7
8pub struct TupleSerializer<'ser, W: 'ser + Write> {
9    ser: &'ser mut Serializer<W>,
10    must_close_tag: bool,
11    first: bool,
12}
13
14impl<'ser, W: 'ser + Write> TupleSerializer<'ser, W> {
15    pub fn new(ser: &'ser mut Serializer<W>, must_close_tag: bool) -> Self {
16        Self {
17            ser,
18            must_close_tag,
19            first: true,
20        }
21    }
22
23    fn serialize_item<T>(&mut self, value: &T) -> Result<()>
24    where
25        T: ?Sized + Serialize,
26    {
27        if self.first {
28            self.first = false;
29        } else {
30            self.ser.characters(" ")?;
31        }
32        value.serialize(&mut *self.ser)?;
33        Ok(())
34    }
35
36    fn after_items(self) -> Result<()> {
37        if self.must_close_tag {
38            self.ser.end_tag()?;
39        }
40        Ok(())
41    }
42}
43
44impl<'ser, W: 'ser + Write> serde::ser::SerializeTupleVariant for TupleSerializer<'ser, W> {
45    type Ok = ();
46    type Error = Error;
47
48    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
49    where
50        T: ?Sized + Serialize,
51    {
52        self.serialize_item(value)
53    }
54
55    fn end(self) -> Result<()> {
56        self.ser.end_tag()?;
57        self.after_items()
58    }
59}
60
61impl<'ser, W: 'ser + Write> serde::ser::SerializeTupleStruct for TupleSerializer<'ser, W> {
62    type Ok = ();
63    type Error = Error;
64
65    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
66    where
67        T: ?Sized + Serialize,
68    {
69        self.serialize_item(value)
70    }
71
72    fn end(self) -> Result<()> {
73        self.after_items()
74    }
75}
76
77impl<'ser, W: 'ser + Write> serde::ser::SerializeTuple for TupleSerializer<'ser, W> {
78    type Ok = ();
79    type Error = Error;
80
81    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
82    where
83        T: ?Sized + Serialize,
84    {
85        self.serialize_item(value)
86    }
87
88    fn end(self) -> Result<()> {
89        self.after_items()
90    }
91}