libconfig_rs/serde/
serialize.rs

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

libconfig_rs/serde/
serialize.rs
