ocapn_syrup/
ser.rs

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

ocapn_syrup/
ser.rs
