serde_xml_rs/ser/
var.rs

1use std::io::Write;
2
3use serde::ser::{self, Serialize};
4
5use crate::error::{Error, Result};
6use crate::ser::Serializer;
7
8/// An implementation of `SerializeMap` for serializing to XML.
9pub struct Map<'w, W>
10where
11    W: Write,
12{
13    parent: &'w mut Serializer<W>,
14}
15
16impl<'w, W> Map<'w, W>
17where
18    W: 'w + Write,
19{
20    pub fn new(parent: &'w mut Serializer<W>) -> Map<'w, W> {
21        Map { parent }
22    }
23}
24
25impl<'w, W> ser::SerializeMap for Map<'w, W>
26where
27    W: 'w + Write,
28{
29    type Ok = ();
30    type Error = Error;
31
32    fn serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<()> {
33        panic!("impossible to serialize the key on its own, please use serialize_entry()")
34    }
35
36    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
37        value.serialize(&mut *self.parent)
38    }
39
40    fn end(self) -> Result<Self::Ok> {
41        Ok(())
42    }
43
44    fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
45        &mut self,
46        key: &K,
47        value: &V,
48    ) -> Result<()> {
49        // TODO: Is it possible to ensure our key is never a composite type?
50        // Anything which isn't a "primitive" would lead to malformed XML here...
51        write!(self.parent.writer, "<")?;
52        key.serialize(&mut *self.parent)?;
53        write!(self.parent.writer, ">")?;
54
55        value.serialize(&mut *self.parent)?;
56
57        write!(self.parent.writer, "</")?;
58        key.serialize(&mut *self.parent)?;
59        write!(self.parent.writer, ">")?;
60        Ok(())
61    }
62}
63
64/// An implementation of `SerializeStruct` for serializing to XML.
65pub struct Struct<'w, W>
66where
67    W: Write,
68{
69    parent: &'w mut Serializer<W>,
70    name: &'w str,
71}
72
73impl<'w, W> Struct<'w, W>
74where
75    W: 'w + Write,
76{
77    pub fn new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W> {
78        Struct { parent, name }
79    }
80}
81
82impl<'w, W> ser::SerializeStruct for Struct<'w, W>
83where
84    W: 'w + Write,
85{
86    type Ok = ();
87    type Error = Error;
88
89    fn serialize_field<T: ?Sized + Serialize>(
90        &mut self,
91        key: &'static str,
92        value: &T,
93    ) -> Result<()> {
94        write!(self.parent.writer, "<{}>", key)?;
95        value.serialize(&mut *self.parent)?;
96        write!(self.parent.writer, "</{}>", key)?;
97        Ok(())
98    }
99
100    fn end(self) -> Result<Self::Ok> {
101        write!(self.parent.writer, "</{}>", self.name).map_err(|e| e.into())
102    }
103}