buni_rs/serialize/
mod.rs

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

buni_rs/serialize/
mod.rs
