1 use crate::{
2     errors::{serialize::DeError, Error},
3     events::{BytesEnd, BytesStart, Event},
4     se::Serializer,
5 };
6 use serde::ser::{self, Serialize};
7 use std::io::Write;
8 
9 /// An implementation of `SerializeMap` for serializing to XML.
10 pub struct Map<'w, W>
11 where
12     W: 'w + Write,
13 {
14     parent: &'w mut Serializer<W>,
15 }
16 
17 impl<'w, W> Map<'w, W>
18 where
19     W: 'w + Write,
20 {
21     /// Create a new Map
new(parent: &'w mut Serializer<W>) -> Map<'w, W>22     pub fn new(parent: &'w mut Serializer<W>) -> Map<'w, W> {
23         Map { parent }
24     }
25 }
26 
27 impl<'w, W> ser::SerializeMap for Map<'w, W>
28 where
29     W: 'w + Write,
30 {
31     type Ok = ();
32     type Error = DeError;
33 
serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<(), DeError>34     fn serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<(), DeError> {
35         Err(DeError::Unsupported(
36             "impossible to serialize the key on its own, please use serialize_entry()",
37         ))
38     }
39 
serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), DeError>40     fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), DeError> {
41         value.serialize(&mut *self.parent)
42     }
43 
end(self) -> Result<Self::Ok, DeError>44     fn end(self) -> Result<Self::Ok, DeError> {
45         Ok(())
46     }
47 
serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>( &mut self, key: &K, value: &V, ) -> Result<(), DeError>48     fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
49         &mut self,
50         key: &K,
51         value: &V,
52     ) -> Result<(), DeError> {
53         // TODO: Is it possible to ensure our key is never a composite type?
54         // Anything which isn't a "primitive" would lead to malformed XML here...
55         write!(self.parent.writer.inner(), "<").map_err(Error::Io)?;
56         key.serialize(&mut *self.parent)?;
57         write!(self.parent.writer.inner(), ">").map_err(Error::Io)?;
58 
59         value.serialize(&mut *self.parent)?;
60 
61         write!(self.parent.writer.inner(), "</").map_err(Error::Io)?;
62         key.serialize(&mut *self.parent)?;
63         write!(self.parent.writer.inner(), ">").map_err(Error::Io)?;
64         Ok(())
65     }
66 }
67 
68 /// An implementation of `SerializeStruct` for serializing to XML.
69 pub struct Struct<'w, W>
70 where
71     W: 'w + Write,
72 {
73     parent: &'w mut Serializer<W>,
74     name: &'w str,
75 }
76 
77 impl<'w, W> Struct<'w, W>
78 where
79     W: 'w + Write,
80 {
81     /// Create a new `Struct`
new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W>82     pub fn new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W> {
83         Struct { parent, name }
84     }
85 }
86 
87 impl<'w, W> ser::SerializeStruct for Struct<'w, W>
88 where
89     W: 'w + Write,
90 {
91     type Ok = ();
92     type Error = DeError;
93 
serialize_field<T: ?Sized + Serialize>( &mut self, key: &'static str, value: &T, ) -> Result<(), DeError>94     fn serialize_field<T: ?Sized + Serialize>(
95         &mut self,
96         key: &'static str,
97         value: &T,
98     ) -> Result<(), DeError> {
99         let key = key.as_bytes();
100         self.parent
101             .writer
102             .write_event(Event::Start(BytesStart::borrowed_name(key)))?;
103         value.serialize(&mut *self.parent)?;
104         self.parent
105             .writer
106             .write_event(Event::End(BytesEnd::borrowed(key)))?;
107         Ok(())
108     }
109 
end(self) -> Result<Self::Ok, DeError>110     fn end(self) -> Result<Self::Ok, DeError> {
111         self.parent
112             .writer
113             .write_event(Event::End(BytesEnd::borrowed(self.name.as_bytes())))?;
114         Ok(())
115     }
116 }
117 
118 /// An implementation of `SerializeSeq' for serializing to XML.
119 pub struct Seq<'w, W>
120 where
121     W: 'w + Write,
122 {
123     parent: &'w mut Serializer<W>,
124 }
125 
126 impl<'w, W> Seq<'w, W>
127 where
128     W: 'w + Write,
129 {
130     /// Create a new `Seq`
new(parent: &'w mut Serializer<W>) -> Seq<'w, W>131     pub fn new(parent: &'w mut Serializer<W>) -> Seq<'w, W> {
132         Seq { parent }
133     }
134 }
135 
136 impl<'w, W> ser::SerializeSeq for Seq<'w, W>
137 where
138     W: 'w + Write,
139 {
140     type Ok = ();
141     type Error = DeError;
142 
serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where T: Serialize,143     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
144     where
145         T: Serialize,
146     {
147         value.serialize(&mut *self.parent)?;
148         Ok(())
149     }
150 
end(self) -> Result<Self::Ok, Self::Error>151     fn end(self) -> Result<Self::Ok, Self::Error> {
152         Ok(())
153     }
154 }
155