libconfig_rs/serde/
serialize.rs

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

libconfig_rs/serde/
serialize.rs
