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