1use serde::{ser, Serialize};
2use crate::error::{Error, Result};
3use std::io::Write;
4
5pub struct Serializer<W> {
6 writer: W,
7 last_key: Option<String>,
8 indent: usize,
9 is_root: bool,
10}
11
12impl<W: Write> Serializer<W> {
13 pub fn new(writer: W) -> Self {
14 Serializer {
15 writer,
16 last_key: None,
17 indent: 0,
18 is_root: true,
19 }
20 }
21
22 fn write_indent(&mut self) -> Result<()> {
23 for _ in 0..self.indent {
24 self.writer.write_all(b"\t")?;
25 }
26 Ok(())
27 }
28
29 fn write_key(&mut self) -> Result<()> {
30 if let Some(key) = self.last_key.clone() {
31 self.write_indent()?;
32 write!(self.writer, "\"{}\"", key)?;
33 self.writer.write_all(b" ")?;
34 }
35 Ok(())
36 }
37}
38
39pub fn to_string<T>(value: &T) -> Result<String>
40where
41 T: Serialize,
42{
43 let mut writer = Vec::new();
44 let mut serializer = Serializer::new(&mut writer);
45 value.serialize(&mut serializer)?;
46 Ok(String::from_utf8(writer).map_err(|e| Error::Message(e.to_string()))?)
47}
48
49impl<'a, W: Write> ser::Serializer for &'a mut Serializer<W> {
50 type Ok = ();
51 type Error = Error;
52
53 type SerializeSeq = SeqSerializer<'a, W>;
54 type SerializeTuple = ser::Impossible<(), Error>;
55 type SerializeTupleStruct = ser::Impossible<(), Error>;
56 type SerializeTupleVariant = ser::Impossible<(), Error>;
57 type SerializeMap = MapSerializer<'a, W>;
58 type SerializeStruct = StructSerializer<'a, W>;
59 type SerializeStructVariant = ser::Impossible<(), Error>;
60
61 fn serialize_bool(self, v: bool) -> Result<()> {
62 self.serialize_str(if v { "1" } else { "0" })
63 }
64
65 fn serialize_i8(self, v: i8) -> Result<()> {
66 self.serialize_str(&v.to_string())
67 }
68
69 fn serialize_i16(self, v: i16) -> Result<()> {
70 self.serialize_str(&v.to_string())
71 }
72
73 fn serialize_i32(self, v: i32) -> Result<()> {
74 self.serialize_str(&v.to_string())
75 }
76
77 fn serialize_i64(self, v: i64) -> Result<()> {
78 self.serialize_str(&v.to_string())
79 }
80
81 fn serialize_u8(self, v: u8) -> Result<()> {
82 self.serialize_str(&v.to_string())
83 }
84
85 fn serialize_u16(self, v: u16) -> Result<()> {
86 self.serialize_str(&v.to_string())
87 }
88
89 fn serialize_u32(self, v: u32) -> Result<()> {
90 self.serialize_str(&v.to_string())
91 }
92
93 fn serialize_u64(self, v: u64) -> Result<()> {
94 self.serialize_str(&v.to_string())
95 }
96
97 fn serialize_f32(self, v: f32) -> Result<()> {
98 self.serialize_str(&v.to_string())
99 }
100
101 fn serialize_f64(self, v: f64) -> Result<()> {
102 self.serialize_str(&v.to_string())
103 }
104
105 fn serialize_char(self, v: char) -> Result<()> {
106 self.serialize_str(&v.to_string())
107 }
108
109 fn serialize_str(self, v: &str) -> Result<()> {
110 self.write_key()?;
111 write!(self.writer, "\"{}\"", v)?;
112 self.writer.write_all(b"\n")?;
113 self.last_key = None;
114 Ok(())
115 }
116
117 fn serialize_bytes(self, _v: &[u8]) -> Result<()> {
118 Err(Error::Message("Bytes serialization not supported".into()))
119 }
120
121 fn serialize_none(self) -> Result<()> {
122 self.last_key = None;
123 Ok(())
124 }
125
126 fn serialize_some<T>(self, value: &T) -> Result<()>
127 where
128 T: ?Sized + Serialize,
129 {
130 value.serialize(self)
131 }
132
133 fn serialize_unit(self) -> Result<()> {
134 self.last_key = None;
135 Ok(())
136 }
137
138 fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
139 self.serialize_unit()
140 }
141
142 fn serialize_unit_variant(
143 self,
144 _name: &'static str,
145 _variant_index: u32,
146 _variant: &'static str,
147 ) -> Result<()> {
148 Err(Error::Message("Unit variant serialization not supported".into()))
149 }
150
151 fn serialize_newtype_struct<T>(
152 self,
153 _name: &'static str,
154 value: &T,
155 ) -> Result<()>
156 where
157 T: ?Sized + Serialize,
158 {
159 value.serialize(self)
160 }
161
162 fn serialize_newtype_variant<T>(
163 self,
164 _name: &'static str,
165 _variant_index: u32,
166 _variant: &'static str,
167 _value: &T,
168 ) -> Result<()>
169 where
170 T: ?Sized + Serialize,
171 {
172 Err(Error::Message("Newtype variant serialization not supported".into()))
173 }
174
175 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
176 let key = self.last_key.take().ok_or(Error::ExpectedKey)?;
177 Ok(SeqSerializer {
178 serializer: self,
179 key,
180 })
181 }
182
183 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
184 Err(Error::Message("Tuple serialization not supported".into()))
185 }
186
187 fn serialize_tuple_struct(
188 self,
189 _name: &'static str,
190 _len: usize,
191 ) -> Result<Self::SerializeTupleStruct> {
192 Err(Error::Message("Tuple struct serialization not supported".into()))
193 }
194
195 fn serialize_tuple_variant(
196 self,
197 _name: &'static str,
198 _variant_index: u32,
199 _variant: &'static str,
200 _len: usize,
201 ) -> Result<Self::SerializeTupleVariant> {
202 Err(Error::Message("Tuple variant serialization not supported".into()))
203 }
204
205 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
206 if self.is_root {
207 self.is_root = false;
208 Ok(MapSerializer {
209 serializer: self,
210 is_root: true,
211 })
212 } else {
213 let key_clone = self.last_key.clone();
214 if let Some(key) = key_clone {
215 self.write_indent()?;
216 write!(self.writer, "{}", key)?;
217 self.writer.write_all(b"\n")?;
218 }
219 self.write_indent()?;
220 self.writer.write_all(b"{\n")?;
221 self.indent += 1;
222 self.last_key = None;
223
224 Ok(MapSerializer {
225 serializer: self,
226 is_root: false,
227 })
228 }
229 }
230
231 fn serialize_struct(
232 self,
233 _name: &'static str,
234 len: usize,
235 ) -> Result<Self::SerializeStruct> {
236 let map = self.serialize_map(Some(len))?;
237 Ok(StructSerializer { map })
238 }
239
240 fn serialize_struct_variant(
241 self,
242 _name: &'static str,
243 _variant_index: u32,
244 _variant: &'static str,
245 _len: usize,
246 ) -> Result<Self::SerializeStructVariant> {
247 Err(Error::Message("Struct variant serialization not supported".into()))
248 }
249}
250
251pub struct SeqSerializer<'a, W> {
252 serializer: &'a mut Serializer<W>,
253 key: String,
254}
255
256impl<'a, W: Write> ser::SerializeSeq for SeqSerializer<'a, W> {
257 type Ok = ();
258 type Error = Error;
259
260 fn serialize_element<T>(&mut self, value: &T) -> Result<()>
261 where
262 T: ?Sized + Serialize,
263 {
264 self.serializer.last_key = Some(self.key.clone());
265 value.serialize(&mut *self.serializer)
266 }
267
268 fn end(self) -> Result<()> {
269 Ok(())
270 }
271}
272
273pub struct MapSerializer<'a, W> {
274 serializer: &'a mut Serializer<W>,
275 is_root: bool,
276}
277
278impl<'a, W: Write> ser::SerializeMap for MapSerializer<'a, W> {
279 type Ok = ();
280 type Error = Error;
281
282 fn serialize_key<T>(&mut self, key: &T) -> Result<()>
283 where
284 T: ?Sized + Serialize,
285 {
286 struct KeyCollector(String);
287 impl<'k> ser::Serializer for &'k mut KeyCollector {
288 type Ok = ();
289 type Error = Error;
290 type SerializeSeq = ser::Impossible<(), Error>;
291 type SerializeTuple = ser::Impossible<(), Error>;
292 type SerializeTupleStruct = ser::Impossible<(), Error>;
293 type SerializeTupleVariant = ser::Impossible<(), Error>;
294 type SerializeMap = ser::Impossible<(), Error>;
295 type SerializeStruct = ser::Impossible<(), Error>;
296 type SerializeStructVariant = ser::Impossible<(), Error>;
297
298 fn serialize_str(self, v: &str) -> Result<()> {
299 self.0 = v.to_string();
300 Ok(())
301 }
302 fn serialize_bool(self, v: bool) -> Result<()> { self.serialize_str(if v { "1" } else { "0" }) }
303 fn serialize_i8(self, v: i8) -> Result<()> { self.serialize_str(&v.to_string()) }
304 fn serialize_i16(self, v: i16) -> Result<()> { self.serialize_str(&v.to_string()) }
305 fn serialize_i32(self, v: i32) -> Result<()> { self.serialize_str(&v.to_string()) }
306 fn serialize_i64(self, v: i64) -> Result<()> { self.serialize_str(&v.to_string()) }
307 fn serialize_u8(self, v: u8) -> Result<()> { self.serialize_str(&v.to_string()) }
308 fn serialize_u16(self, v: u16) -> Result<()> { self.serialize_str(&v.to_string()) }
309 fn serialize_u32(self, v: u32) -> Result<()> { self.serialize_str(&v.to_string()) }
310 fn serialize_u64(self, v: u64) -> Result<()> { self.serialize_str(&v.to_string()) }
311 fn serialize_f32(self, v: f32) -> Result<()> { self.serialize_str(&v.to_string()) }
312 fn serialize_f64(self, v: f64) -> Result<()> { self.serialize_str(&v.to_string()) }
313 fn serialize_char(self, v: char) -> Result<()> { self.serialize_str(&v.to_string()) }
314 fn serialize_bytes(self, _v: &[u8]) -> Result<()> { Err(Error::ExpectedString) }
315 fn serialize_none(self) -> Result<()> { Err(Error::ExpectedString) }
316 fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<()> { value.serialize(self) }
317 fn serialize_unit(self) -> Result<()> { Err(Error::ExpectedString) }
318 fn serialize_unit_struct(self, _name: &'static str) -> Result<()> { Err(Error::ExpectedString) }
319 fn serialize_unit_variant(self, _name: &'static str, _idx: u32, _var: &'static str) -> Result<()> { Err(Error::ExpectedString) }
320 fn serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, value: &T) -> Result<()> { value.serialize(self) }
321 fn serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _idx: u32, _var: &'static str, _val: &T) -> Result<()> { Err(Error::ExpectedString) }
322 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> { Err(Error::ExpectedString) }
323 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> { Err(Error::ExpectedString) }
324 fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> { Err(Error::ExpectedString) }
325 fn serialize_tuple_variant(self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant> { Err(Error::ExpectedString) }
326 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> { Err(Error::ExpectedString) }
327 fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> { Err(Error::ExpectedString) }
328 fn serialize_struct_variant(self, _name: &'static str, _idx: u32, _var: &'static str, _len: usize) -> Result<Self::SerializeStructVariant> { Err(Error::ExpectedString) }
329 }
330
331 let mut collector = KeyCollector(String::new());
332 key.serialize(&mut collector)?;
333 self.serializer.last_key = Some(collector.0);
334 Ok(())
335 }
336
337 fn serialize_value<T>(&mut self, value: &T) -> Result<()>
338 where
339 T: ?Sized + Serialize,
340 {
341 value.serialize(&mut *self.serializer)
342 }
343
344 fn end(self) -> Result<()> {
345 if !self.is_root {
346 self.serializer.indent -= 1;
347 self.serializer.write_indent()?;
348 self.serializer.writer.write_all(b"}\n")?;
349 }
350 Ok(())
351 }
352}
353
354pub struct StructSerializer<'a, W> {
355 map: MapSerializer<'a, W>,
356}
357
358impl<'a, W: Write> ser::SerializeStruct for StructSerializer<'a, W> {
359 type Ok = ();
360 type Error = Error;
361
362 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
363 where
364 T: ?Sized + Serialize,
365 {
366 use ser::SerializeMap;
367 self.map.serialize_entry(key, value)
368 }
369
370 fn end(self) -> Result<()> {
371 use ser::SerializeMap;
372 self.map.end()
373 }
374}