serde_xml_rs/ser/
mod.rs

1mod child;
2mod map;
3mod plain;
4mod seq;
5mod tuple;
6mod writer;
7
8use self::{child::ChildSerializer, map::StructSerializer, tuple::TupleSerializer};
9use crate::{
10    config::{Namespaces, SerdeXml},
11    error::{Error, Result},
12};
13use log::trace;
14use serde::Serialize;
15use std::io::Write;
16use writer::Writer;
17use xml::EventWriter;
18
19/// A convenience method for serializing some object to a string.
20///
21/// # Examples
22///
23/// ```rust
24/// # use serde::Serialize;
25/// # use serde_xml_rs::to_string;
26/// #[derive(Serialize)]
27/// struct Person {
28///   name: String,
29///   age: u32,
30/// }
31///
32/// # fn main() {
33///
34/// let joe = Person {name: "Joe".to_string(), age: 42};
35/// let serialized = to_string(&joe).unwrap();
36/// println!("{}", serialized);
37/// # }
38/// ```
39pub fn to_string<S: Serialize>(value: &S) -> Result<String> {
40    let mut buffer = Vec::new();
41    to_writer(&mut buffer, value)?;
42    Ok(String::from_utf8(buffer)?)
43}
44
45/// A convenience method for serializing some object to a buffer.
46///
47/// # Examples
48///
49/// ```rust
50/// # use serde::Serialize;
51/// # use serde_xml_rs::to_writer;
52/// #[derive(Serialize)]
53/// struct Person {
54///   name: String,
55///   age: u32,
56/// }
57///
58/// # fn main() {
59/// let mut buffer = Vec::new();
60/// let joe = Person {name: "Joe".to_string(), age: 42};
61///
62/// to_writer(&mut buffer, &joe).unwrap();
63///
64/// let serialized = String::from_utf8(buffer).unwrap();
65/// println!("{}", serialized);
66/// # }
67/// ```
68pub fn to_writer<W: Write, S: Serialize>(writer: W, value: &S) -> Result<()> {
69    let mut serializer = Serializer::from_config(SerdeXml::default(), writer);
70    value.serialize(&mut serializer)
71}
72
73/// An XML `Serializer`.
74pub struct Serializer<W> {
75    writer: Writer<W>,
76}
77
78impl<W: Write> Serializer<W> {
79    pub fn new(writer: EventWriter<W>) -> Self {
80        Self {
81            writer: Writer::new(writer, Namespaces::default()),
82        }
83    }
84
85    pub fn new_from_writer(writer: W) -> Self {
86        Self::from_config(SerdeXml::default(), writer)
87    }
88
89    pub fn into_inner(self) -> W {
90        self.writer.into_inner()
91    }
92
93    pub(crate) fn from_config(config: SerdeXml, sink: W) -> Self {
94        Self {
95            writer: Writer::new(config.emitter.create_writer(sink), config.namespaces),
96        }
97    }
98}
99
100impl<'a, W: Write> serde::ser::Serializer for &'a mut Serializer<W> {
101    type Ok = ();
102    type Error = Error;
103
104    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
105    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
106    type SerializeTupleStruct = TupleSerializer<'a, W>;
107    type SerializeTupleVariant = TupleSerializer<'a, W>;
108    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
109    type SerializeStruct = StructSerializer<'a, W>;
110    type SerializeStructVariant = StructSerializer<'a, W>;
111
112    fn serialize_bool(self, _v: bool) -> Result<Self::Ok> {
113        Err(Error::Unsupported("bool in document root"))
114    }
115
116    fn serialize_i8(self, _v: i8) -> Result<Self::Ok> {
117        Err(Error::Unsupported("integer in document root"))
118    }
119
120    fn serialize_i16(self, _v: i16) -> Result<Self::Ok> {
121        Err(Error::Unsupported("integer in document root"))
122    }
123
124    fn serialize_i32(self, _v: i32) -> Result<Self::Ok> {
125        Err(Error::Unsupported("integer in document root"))
126    }
127
128    fn serialize_i64(self, _v: i64) -> Result<Self::Ok> {
129        Err(Error::Unsupported("integer in document root"))
130    }
131
132    fn serialize_u8(self, _v: u8) -> Result<Self::Ok> {
133        Err(Error::Unsupported("integer in document root"))
134    }
135
136    fn serialize_u16(self, _v: u16) -> Result<Self::Ok> {
137        Err(Error::Unsupported("integer in document root"))
138    }
139
140    fn serialize_u32(self, _v: u32) -> Result<Self::Ok> {
141        Err(Error::Unsupported("integer in document root"))
142    }
143
144    fn serialize_u64(self, _v: u64) -> Result<Self::Ok> {
145        Err(Error::Unsupported("integer in document root"))
146    }
147
148    fn serialize_f32(self, _v: f32) -> Result<Self::Ok> {
149        Err(Error::Unsupported("float in document root"))
150    }
151
152    fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
153        Err(Error::Unsupported("float in document root"))
154    }
155
156    fn serialize_char(self, _v: char) -> Result<Self::Ok> {
157        Err(Error::Unsupported("char in document root"))
158    }
159
160    fn serialize_str(self, _v: &str) -> Result<Self::Ok> {
161        Err(Error::Unsupported("string in document root"))
162    }
163
164    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok> {
165        Err(Error::Unsupported("bytes"))
166    }
167
168    fn serialize_none(self) -> Result<Self::Ok> {
169        trace!("none");
170        Ok(())
171    }
172
173    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
174    where
175        T: ?Sized + Serialize,
176    {
177        trace!("some");
178        value.serialize(self)
179    }
180
181    fn serialize_unit(self) -> Result<Self::Ok> {
182        Err(Error::Unsupported("unit in document root"))
183    }
184
185    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
186        trace!("unit struct '{name}'");
187        self.writer.start_element(name)?;
188        self.writer.end_element()?;
189        Ok(())
190    }
191
192    fn serialize_unit_variant(
193        self,
194        name: &'static str,
195        _variant_index: u32,
196        variant: &'static str,
197    ) -> Result<Self::Ok> {
198        trace!("unit variant '{name}' '{variant}'");
199        self.writer.start_element(name)?;
200        self.writer.start_element(variant)?;
201        self.writer.end_element()?;
202        self.writer.end_element()?;
203        Ok(())
204    }
205
206    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Self::Ok>
207    where
208        T: ?Sized + Serialize,
209    {
210        trace!("newtype struct '{name}'");
211        value.serialize(ChildSerializer::for_newtype_struct(
212            &mut self.writer,
213            name.to_string(),
214        ))?;
215        Ok(())
216    }
217
218    fn serialize_newtype_variant<T>(
219        self,
220        name: &'static str,
221        _variant_index: u32,
222        variant: &'static str,
223        value: &T,
224    ) -> Result<Self::Ok>
225    where
226        T: ?Sized + Serialize,
227    {
228        trace!("newtype variant '{name}' '{variant}'");
229        self.writer.start_element(name)?;
230        value.serialize(ChildSerializer::new(
231            &mut self.writer,
232            Some(variant.to_string()),
233        ))?;
234        self.writer.end_element()?;
235        Ok(())
236    }
237
238    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
239        Err(Error::Unsupported("sequence in document root"))
240    }
241
242    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
243        Err(Error::Unsupported("tuple in document root"))
244    }
245
246    fn serialize_tuple_struct(
247        self,
248        name: &'static str,
249        _len: usize,
250    ) -> Result<Self::SerializeTupleStruct> {
251        trace!("tuple struct '{name}'");
252        self.writer.start_element(name)?;
253        Ok(TupleSerializer::new(&mut self.writer, true))
254    }
255
256    fn serialize_tuple_variant(
257        self,
258        name: &'static str,
259        _variant_index: u32,
260        variant: &'static str,
261        _len: usize,
262    ) -> Result<Self::SerializeTupleVariant> {
263        trace!("tuple variant '{name}' '{variant}'");
264        self.writer.start_element(name)?;
265        self.writer.start_element(variant)?;
266        Ok(TupleSerializer::new(&mut self.writer, true))
267    }
268
269    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
270        Err(Error::Unsupported("map in document root"))
271    }
272
273    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
274        trace!("struct '{name}'");
275        Ok(StructSerializer::new(&mut self.writer, name.to_string()))
276    }
277
278    fn serialize_struct_variant(
279        self,
280        name: &'static str,
281        _variant_index: u32,
282        variant: &'static str,
283        _len: usize,
284    ) -> Result<Self::SerializeStructVariant> {
285        trace!("struct variant '{name}' '{variant}'");
286        Ok(StructSerializer::new_variant(
287            &mut self.writer,
288            Some(name.to_string()),
289            variant.to_string(),
290        ))
291    }
292}
serde_xml_rs/ser/mod.rs

serde_xml_rs/ser/
mod.rs
