serde_watson/
ser.rs

1use std::io;
2
3use serde::ser;
4use watson_rs::serializer;
5use watson_rs::serializer::WriteInsn;
6use watson_rs::unlexer;
7use watson_rs::{Insn, Value};
8
9use crate::error::{Error, Result};
10
11/// Serializer implements serde::ser::Serializer for WATSON encoding.
12pub struct Serializer<W> {
13    inner: serializer::Serializer<W>,
14}
15
16impl<W> Serializer<W> {
17    /// Returns a new `Serializer` that writes to the given writer.
18    pub fn new(writer: W) -> Self {
19        Serializer {
20            inner: serializer::Serializer::new(writer),
21        }
22    }
23
24    /// Unwraps the inner value from this `Serializer`.
25    pub fn into_inner(self) -> W {
26        self.inner.into_inner()
27    }
28}
29
30impl<W> Serializer<unlexer::Unlexer<W>>
31where
32    W: io::Write,
33{
34    /// Returns a new `Serializer` that writes to the given `io::Write`.
35    pub fn from_writer(writer: W) -> Self {
36        Serializer {
37            inner: serializer::Serializer::new(unlexer::Unlexer::new(writer)),
38        }
39    }
40}
41
42impl<'a, W> ser::Serializer for &'a mut Serializer<W>
43where
44    W: WriteInsn,
45{
46    type Ok = ();
47    type Error = Error;
48    type SerializeSeq = SerializeSeq<'a, W>;
49    type SerializeTuple = SerializeTuple<'a, W>;
50    type SerializeTupleStruct = SerializeTupleStruct<'a, W>;
51    type SerializeTupleVariant = SerializeTupleVariant<'a, W>;
52    type SerializeMap = SerializeMap<'a, W>;
53    type SerializeStruct = SerializeStruct<'a, W>;
54    type SerializeStructVariant = SerializeStructVariant<'a, W>;
55
56    fn serialize_bool(self, v: bool) -> Result<()> {
57        self.inner.serialize(&Value::Bool(v))?;
58        Ok(())
59    }
60
61    fn serialize_i8(self, v: i8) -> Result<()> {
62        self.inner.serialize(&Value::Int(v as i64))?;
63        Ok(())
64    }
65
66    fn serialize_i16(self, v: i16) -> Result<()> {
67        self.inner.serialize(&Value::Int(v as i64))?;
68        Ok(())
69    }
70
71    fn serialize_i32(self, v: i32) -> Result<()> {
72        self.inner.serialize(&Value::Int(v as i64))?;
73        Ok(())
74    }
75
76    fn serialize_i64(self, v: i64) -> Result<()> {
77        self.inner.serialize(&Value::Int(v as i64))?;
78        Ok(())
79    }
80
81    fn serialize_u8(self, v: u8) -> Result<()> {
82        self.inner.serialize(&Value::Uint(v as u64))?;
83        Ok(())
84    }
85
86    fn serialize_u16(self, v: u16) -> Result<()> {
87        self.inner.serialize(&Value::Uint(v as u64))?;
88        Ok(())
89    }
90
91    fn serialize_u32(self, v: u32) -> Result<()> {
92        self.inner.serialize(&Value::Uint(v as u64))?;
93        Ok(())
94    }
95
96    fn serialize_u64(self, v: u64) -> Result<()> {
97        self.inner.serialize(&Value::Uint(v as u64))?;
98        Ok(())
99    }
100
101    fn serialize_f32(self, v: f32) -> Result<()> {
102        self.inner.serialize(&Value::Float(v as f64))?;
103        Ok(())
104    }
105
106    fn serialize_f64(self, v: f64) -> Result<()> {
107        self.inner.serialize(&Value::Float(v as f64))?;
108        Ok(())
109    }
110
111    fn serialize_char(self, v: char) -> Result<()> {
112        let mut buf = [0; 4];
113        self.serialize_str(v.encode_utf8(&mut buf))
114    }
115
116    fn serialize_str(self, v: &str) -> Result<()> {
117        self.serialize_bytes(v.as_bytes())
118    }
119
120    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
121        self.inner.serialize(&Value::String(v.to_vec()))?;
122        Ok(())
123    }
124
125    fn serialize_none(self) -> Result<()> {
126        self.inner.serialize(&Value::Nil)?;
127        Ok(())
128    }
129
130    fn serialize_some<T>(self, value: &T) -> Result<()>
131    where
132        T: ?Sized + ser::Serialize,
133    {
134        value.serialize(self)
135    }
136
137    fn serialize_unit(self) -> Result<()> {
138        self.inner.serialize(&Value::Nil)?;
139        Ok(())
140    }
141
142    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
143        self.inner.serialize(&Value::Nil)?;
144        Ok(())
145    }
146
147    fn serialize_unit_variant(
148        self,
149        _name: &'static str,
150        _variant_index: u32,
151        variant: &'static str,
152    ) -> Result<()> {
153        self.serialize_str(variant)
154    }
155
156    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<()>
157    where
158        T: ?Sized + ser::Serialize,
159    {
160        self.inner.write(Insn::Onew)?;
161        self.serialize_str(name)?;
162        value.serialize(&mut *self)?;
163        self.inner.write(Insn::Oadd)?;
164        Ok(())
165    }
166
167    fn serialize_newtype_variant<T>(
168        self,
169        _name: &'static str,
170        _variant_index: u32,
171        variant: &'static str,
172        value: &T,
173    ) -> Result<()>
174    where
175        T: ?Sized + ser::Serialize,
176    {
177        self.inner.write(Insn::Onew)?;
178        self.serialize_str(variant)?;
179        value.serialize(&mut *self)?;
180        self.inner.write(Insn::Oadd)?;
181        Ok(())
182    }
183
184    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
185        self.inner.write(Insn::Anew)?;
186        Ok(SerializeSeq { ser: self })
187    }
188
189    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
190        self.serialize_seq(None)
191    }
192
193    fn serialize_tuple_struct(
194        self,
195        _name: &'static str,
196        _len: usize,
197    ) -> Result<Self::SerializeTupleStruct> {
198        self.serialize_seq(None)
199    }
200
201    fn serialize_tuple_variant(
202        self,
203        _name: &'static str,
204        _variant_index: u32,
205        variant: &'static str,
206        _len: usize,
207    ) -> Result<Self::SerializeTupleVariant> {
208        self.inner.write(Insn::Onew)?;
209        self.serialize_str(variant)?;
210        self.serialize_seq(None)
211    }
212
213    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
214        self.inner.write(Insn::Onew)?;
215        Ok(SerializeMap { ser: self })
216    }
217
218    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
219        self.serialize_map(None)
220    }
221
222    fn serialize_struct_variant(
223        self,
224        _name: &'static str,
225        _variant_index: u32,
226        variant: &'static str,
227        _len: usize,
228    ) -> Result<Self::SerializeStructVariant> {
229        self.inner.write(Insn::Onew)?;
230        self.serialize_str(variant)?;
231        self.serialize_map(None)
232    }
233}
234
235pub struct SerializeSeq<'a, W> {
236    ser: &'a mut Serializer<W>,
237}
238
239impl<'a, W> ser::SerializeSeq for SerializeSeq<'a, W>
240where
241    W: WriteInsn,
242{
243    type Ok = ();
244    type Error = Error;
245
246    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
247    where
248        T: ?Sized + ser::Serialize,
249    {
250        value.serialize(&mut *self.ser)?;
251        self.ser.inner.write(Insn::Aadd)?;
252        Ok(())
253    }
254
255    fn end(self) -> Result<()> {
256        Ok(())
257    }
258}
259
260type SerializeTuple<'a, W> = SerializeSeq<'a, W>;
261
262impl<'a, W> ser::SerializeTuple for SerializeTuple<'a, W>
263where
264    W: WriteInsn,
265{
266    type Ok = ();
267    type Error = Error;
268
269    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
270    where
271        T: ?Sized + ser::Serialize,
272    {
273        ser::SerializeSeq::serialize_element(self, value)
274    }
275
276    fn end(self) -> Result<()> {
277        ser::SerializeSeq::end(self)
278    }
279}
280
281type SerializeTupleStruct<'a, W> = SerializeSeq<'a, W>;
282
283impl<'a, W> ser::SerializeTupleStruct for SerializeTupleStruct<'a, W>
284where
285    W: WriteInsn,
286{
287    type Ok = ();
288    type Error = Error;
289
290    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
291    where
292        T: ?Sized + ser::Serialize,
293    {
294        ser::SerializeSeq::serialize_element(self, value)
295    }
296
297    fn end(self) -> Result<()> {
298        ser::SerializeSeq::end(self)
299    }
300}
301
302type SerializeTupleVariant<'a, W> = SerializeSeq<'a, W>;
303
304impl<'a, W> ser::SerializeTupleVariant for SerializeTupleVariant<'a, W>
305where
306    W: WriteInsn,
307{
308    type Ok = ();
309    type Error = Error;
310
311    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
312    where
313        T: ?Sized + ser::Serialize,
314    {
315        ser::SerializeSeq::serialize_element(self, value)
316    }
317
318    fn end(self) -> Result<()> {
319        self.ser.inner.write(Insn::Oadd)?;
320        ser::SerializeSeq::end(self)
321    }
322}
323
324pub struct SerializeMap<'a, W> {
325    ser: &'a mut Serializer<W>,
326}
327
328impl<'a, W> ser::SerializeMap for SerializeMap<'a, W>
329where
330    W: WriteInsn,
331{
332    type Ok = ();
333    type Error = Error;
334
335    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
336    where
337        T: ?Sized + ser::Serialize,
338    {
339        key.serialize(MapKeySerializer {
340            ser: &mut *self.ser,
341        })
342    }
343
344    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
345    where
346        T: ?Sized + ser::Serialize,
347    {
348        value.serialize(&mut *self.ser)?;
349        self.ser.inner.write(Insn::Oadd)?;
350        Ok(())
351    }
352
353    fn end(self) -> Result<()> {
354        Ok(())
355    }
356}
357
358type SerializeStruct<'a, W> = SerializeMap<'a, W>;
359
360impl<'a, W> ser::SerializeStruct for SerializeStruct<'a, W>
361where
362    W: WriteInsn,
363{
364    type Ok = ();
365    type Error = Error;
366
367    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
368    where
369        T: ?Sized + ser::Serialize,
370    {
371        ser::SerializeMap::serialize_key(&mut *self, key)?;
372        ser::SerializeMap::serialize_value(&mut *self, value)?;
373        Ok(())
374    }
375
376    fn end(self) -> Result<()> {
377        ser::SerializeMap::end(self)
378    }
379}
380
381type SerializeStructVariant<'a, W> = SerializeMap<'a, W>;
382
383impl<'a, W> ser::SerializeStructVariant for SerializeStructVariant<'a, W>
384where
385    W: WriteInsn,
386{
387    type Ok = ();
388    type Error = Error;
389
390    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
391    where
392        T: ?Sized + ser::Serialize,
393    {
394        ser::SerializeMap::serialize_entry(self, key, value)
395    }
396
397    fn end(self) -> Result<()> {
398        self.ser.inner.write(Insn::Oadd)?;
399        ser::SerializeMap::end(self)
400    }
401}
402
403struct MapKeySerializer<'a, W> {
404    ser: &'a mut Serializer<W>,
405}
406
407impl<'a, W> ser::Serializer for MapKeySerializer<'a, W>
408where
409    W: WriteInsn,
410{
411    type Ok = ();
412    type Error = Error;
413    type SerializeSeq = SerializeMapKeySeq<'a, W>;
414    type SerializeTuple = ser::Impossible<(), Error>;
415    type SerializeTupleStruct = ser::Impossible<(), Error>;
416    type SerializeTupleVariant = ser::Impossible<(), Error>;
417    type SerializeMap = ser::Impossible<(), Error>;
418    type SerializeStruct = ser::Impossible<(), Error>;
419    type SerializeStructVariant = ser::Impossible<(), Error>;
420
421    fn serialize_bool(self, v: bool) -> Result<()> {
422        if v {
423            self.ser.serialize_bytes(&[1])
424        } else {
425            self.ser.serialize_bytes(&[0])
426        }
427    }
428
429    fn serialize_i8(self, v: i8) -> Result<()> {
430        self.ser.serialize_bytes(&v.to_be_bytes())
431    }
432
433    fn serialize_i16(self, v: i16) -> Result<()> {
434        self.ser.serialize_bytes(&v.to_be_bytes())
435    }
436
437    fn serialize_i32(self, v: i32) -> Result<()> {
438        self.ser.serialize_bytes(&v.to_be_bytes())
439    }
440
441    fn serialize_i64(self, v: i64) -> Result<()> {
442        self.ser.serialize_bytes(&v.to_be_bytes())
443    }
444
445    fn serialize_u8(self, v: u8) -> Result<()> {
446        self.ser.serialize_bytes(&v.to_be_bytes())
447    }
448
449    fn serialize_u16(self, v: u16) -> Result<()> {
450        self.ser.serialize_bytes(&v.to_be_bytes())
451    }
452
453    fn serialize_u32(self, v: u32) -> Result<()> {
454        self.ser.serialize_bytes(&v.to_be_bytes())
455    }
456
457    fn serialize_u64(self, v: u64) -> Result<()> {
458        self.ser.serialize_bytes(&v.to_be_bytes())
459    }
460
461    fn serialize_f32(self, _v: f32) -> Result<()> {
462        Err(Error::key_must_be_bytes())
463    }
464
465    fn serialize_f64(self, _v: f64) -> Result<()> {
466        Err(Error::key_must_be_bytes())
467    }
468
469    fn serialize_char(self, v: char) -> Result<()> {
470        let mut buf = [0; 4];
471        self.ser.serialize_str(v.encode_utf8(&mut buf))
472    }
473
474    fn serialize_str(self, v: &str) -> Result<()> {
475        self.ser.serialize_str(v)
476    }
477
478    fn serialize_bytes(self, v: &[u8]) -> Result<()> {
479        self.ser.serialize_bytes(v)
480    }
481
482    fn serialize_none(self) -> Result<()> {
483        Err(Error::key_must_be_bytes())
484    }
485
486    fn serialize_some<T>(self, _value: &T) -> Result<()>
487    where
488        T: ?Sized + ser::Serialize,
489    {
490        Err(Error::key_must_be_bytes())
491    }
492
493    fn serialize_unit(self) -> Result<()> {
494        Err(Error::key_must_be_bytes())
495    }
496
497    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
498        Err(Error::key_must_be_bytes())
499    }
500
501    fn serialize_unit_variant(
502        self,
503        _name: &'static str,
504        _variant_index: u32,
505        variant: &'static str,
506    ) -> Result<()> {
507        self.ser.serialize_str(variant)
508    }
509
510    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
511    where
512        T: ?Sized + ser::Serialize,
513    {
514        value.serialize(self)
515    }
516
517    fn serialize_newtype_variant<T>(
518        self,
519        _name: &'static str,
520        _variant_index: u32,
521        _variant: &'static str,
522        _value: &T,
523    ) -> Result<()>
524    where
525        T: ?Sized + ser::Serialize,
526    {
527        Err(Error::key_must_be_bytes())
528    }
529
530    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
531        self.ser.inner.write(Insn::Snew)?;
532        Ok(SerializeMapKeySeq {
533            ser: &mut *self.ser,
534        })
535    }
536
537    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
538        Err(Error::key_must_be_bytes())
539    }
540
541    fn serialize_tuple_struct(
542        self,
543        _name: &'static str,
544        _len: usize,
545    ) -> Result<Self::SerializeTupleStruct> {
546        Err(Error::key_must_be_bytes())
547    }
548
549    fn serialize_tuple_variant(
550        self,
551        _name: &'static str,
552        _variant_index: u32,
553        _variant: &'static str,
554        _len: usize,
555    ) -> Result<Self::SerializeTupleVariant> {
556        Err(Error::key_must_be_bytes())
557    }
558
559    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
560        Err(Error::key_must_be_bytes())
561    }
562
563    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
564        Err(Error::key_must_be_bytes())
565    }
566
567    fn serialize_struct_variant(
568        self,
569        _name: &'static str,
570        _variant_index: u32,
571        _variant: &'static str,
572        _len: usize,
573    ) -> Result<Self::SerializeStructVariant> {
574        Err(Error::key_must_be_bytes())
575    }
576}
577
578struct SerializeMapKeySeq<'a, W> {
579    ser: &'a mut Serializer<W>,
580}
581
582impl<'a, W> ser::SerializeSeq for SerializeMapKeySeq<'a, W>
583where
584    W: WriteInsn,
585{
586    type Ok = ();
587    type Error = Error;
588
589    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
590    where
591        T: ?Sized + ser::Serialize,
592    {
593        value.serialize(MapKeyBytesSerializer {
594            ser: &mut *self.ser,
595        })
596    }
597
598    fn end(self) -> Result<()> {
599        Ok(())
600    }
601}
602
603struct MapKeyBytesSerializer<'a, W> {
604    ser: &'a mut Serializer<W>,
605}
606
607impl<'a, W> ser::Serializer for MapKeyBytesSerializer<'a, W>
608where
609    W: WriteInsn,
610{
611    type Ok = ();
612    type Error = Error;
613    type SerializeSeq = ser::Impossible<(), Error>;
614    type SerializeTuple = ser::Impossible<(), Error>;
615    type SerializeTupleStruct = ser::Impossible<(), Error>;
616    type SerializeTupleVariant = ser::Impossible<(), Error>;
617    type SerializeMap = ser::Impossible<(), Error>;
618    type SerializeStruct = ser::Impossible<(), Error>;
619    type SerializeStructVariant = ser::Impossible<(), Error>;
620
621    fn serialize_bool(self, _v: bool) -> Result<()> {
622        Err(Error::key_must_be_bytes())
623    }
624
625    fn serialize_i8(self, _v: i8) -> Result<()> {
626        Err(Error::key_must_be_bytes())
627    }
628
629    fn serialize_i16(self, _v: i16) -> Result<()> {
630        Err(Error::key_must_be_bytes())
631    }
632
633    fn serialize_i32(self, _v: i32) -> Result<()> {
634        Err(Error::key_must_be_bytes())
635    }
636
637    fn serialize_i64(self, _v: i64) -> Result<()> {
638        Err(Error::key_must_be_bytes())
639    }
640
641    fn serialize_u8(self, v: u8) -> Result<()> {
642        self.ser.serialize_i8(v as i8)?;
643        self.ser.inner.write(Insn::Sadd)?;
644        Ok(())
645    }
646
647    fn serialize_u16(self, _v: u16) -> Result<()> {
648        Err(Error::key_must_be_bytes())
649    }
650
651    fn serialize_u32(self, _v: u32) -> Result<()> {
652        Err(Error::key_must_be_bytes())
653    }
654
655    fn serialize_u64(self, _v: u64) -> Result<()> {
656        Err(Error::key_must_be_bytes())
657    }
658
659    fn serialize_f32(self, _v: f32) -> Result<()> {
660        Err(Error::key_must_be_bytes())
661    }
662
663    fn serialize_f64(self, _v: f64) -> Result<()> {
664        Err(Error::key_must_be_bytes())
665    }
666
667    fn serialize_char(self, _v: char) -> Result<()> {
668        Err(Error::key_must_be_bytes())
669    }
670
671    fn serialize_str(self, _v: &str) -> Result<()> {
672        Err(Error::key_must_be_bytes())
673    }
674
675    fn serialize_bytes(self, _v: &[u8]) -> Result<()> {
676        Err(Error::key_must_be_bytes())
677    }
678
679    fn serialize_none(self) -> Result<()> {
680        Err(Error::key_must_be_bytes())
681    }
682
683    fn serialize_some<T>(self, _value: &T) -> Result<()>
684    where
685        T: ?Sized + ser::Serialize,
686    {
687        Err(Error::key_must_be_bytes())
688    }
689
690    fn serialize_unit(self) -> Result<()> {
691        Err(Error::key_must_be_bytes())
692    }
693
694    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
695        Err(Error::key_must_be_bytes())
696    }
697
698    fn serialize_unit_variant(
699        self,
700        _name: &'static str,
701        _variant_index: u32,
702        _variant: &'static str,
703    ) -> Result<()> {
704        Err(Error::key_must_be_bytes())
705    }
706
707    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
708    where
709        T: ?Sized + ser::Serialize,
710    {
711        Err(Error::key_must_be_bytes())
712    }
713
714    fn serialize_newtype_variant<T>(
715        self,
716        _name: &'static str,
717        _variant_index: u32,
718        _variant: &'static str,
719        _value: &T,
720    ) -> Result<()>
721    where
722        T: ?Sized + ser::Serialize,
723    {
724        Err(Error::key_must_be_bytes())
725    }
726
727    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
728        Err(Error::key_must_be_bytes())
729    }
730
731    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
732        Err(Error::key_must_be_bytes())
733    }
734
735    fn serialize_tuple_struct(
736        self,
737        _name: &'static str,
738        _len: usize,
739    ) -> Result<Self::SerializeTupleStruct> {
740        Err(Error::key_must_be_bytes())
741    }
742
743    fn serialize_tuple_variant(
744        self,
745        _name: &'static str,
746        _variant_index: u32,
747        _variant: &'static str,
748        _len: usize,
749    ) -> Result<Self::SerializeTupleVariant> {
750        Err(Error::key_must_be_bytes())
751    }
752
753    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
754        Err(Error::key_must_be_bytes())
755    }
756
757    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
758        Err(Error::key_must_be_bytes())
759    }
760
761    fn serialize_struct_variant(
762        self,
763        _name: &'static str,
764        _variant_index: u32,
765        _variant: &'static str,
766        _len: usize,
767    ) -> Result<Self::SerializeStructVariant> {
768        Err(Error::key_must_be_bytes())
769    }
770}
771
772#[cfg(test)]
773mod test {
774    use std::fmt;
775
776    use serde::ser::Serializer as SerdeSerializer;
777    use serde::Serialize;
778    use watson_rs::ToBytes;
779    use watson_rs::Value::*;
780    use watson_rs::{array, object};
781
782    use super::*;
783
784    #[test]
785    fn serialize_bool() {
786        assert_encodes(true, Bool(true));
787        assert_encodes(false, Bool(false));
788    }
789
790    #[test]
791    fn serialize_i8() {
792        assert_encodes(0_i8, Int(0));
793        assert_encodes(1_i8, Int(1));
794        assert_encodes(127_i8, Int(127));
795        assert_encodes(-1_i8, Int(-1));
796        assert_encodes(-128_i8, Int(-128));
797    }
798
799    #[test]
800    fn serialize_i16() {
801        assert_encodes(0_i16, Int(0));
802        assert_encodes(1_i16, Int(1));
803        assert_encodes(32767_i16, Int(32767));
804        assert_encodes(-1_i16, Int(-1));
805        assert_encodes(-32768_i16, Int(-32768));
806    }
807
808    #[test]
809    fn serialize_i32() {
810        assert_encodes(0_i32, Int(0));
811        assert_encodes(1_i32, Int(1));
812        assert_encodes(2147483647_i32, Int(2147483647));
813        assert_encodes(-1_i32, Int(-1));
814        assert_encodes(-2147483647_i32, Int(-2147483647));
815    }
816
817    #[test]
818    fn serialize_i64() {
819        assert_encodes(0_i64, Int(0));
820        assert_encodes(1_i64, Int(1));
821        assert_encodes(9223372036854775807_i64, Int(9223372036854775807_i64));
822        assert_encodes(-1_i64, Int(-1));
823        assert_encodes(-9223372036854775808_i64, Int(-9223372036854775808_i64));
824    }
825
826    #[test]
827    fn serialize_u8() {
828        assert_encodes(0_u8, Uint(0));
829        assert_encodes(1_u8, Uint(1));
830        assert_encodes(255_u8, Uint(255));
831    }
832
833    #[test]
834    fn serialize_u16() {
835        assert_encodes(0_u16, Uint(0));
836        assert_encodes(1_u16, Uint(1));
837        assert_encodes(65535_u16, Uint(65535));
838    }
839
840    #[test]
841    fn serialize_u32() {
842        assert_encodes(0_u32, Uint(0));
843        assert_encodes(1_u32, Uint(1));
844        assert_encodes(4294967295_u32, Uint(4294967295));
845    }
846
847    #[test]
848    fn serialize_u64() {
849        assert_encodes(0_u64, Uint(0));
850        assert_encodes(1_u64, Uint(1));
851        assert_encodes(18446744073709551615_u64, Uint(18446744073709551615));
852    }
853
854    #[test]
855    fn serialize_f32() {
856        assert_encodes_to_float_satisfying(f32::NAN, |f| f.is_nan());
857        assert_encodes_to_float_satisfying(f32::INFINITY, |f| {
858            f.is_sign_positive() && f.is_infinite()
859        });
860        assert_encodes_to_float_satisfying(f32::NEG_INFINITY, |f| {
861            f.is_sign_negative() && f.is_infinite()
862        });
863        assert_encodes(1.25_f32, Float(1.25));
864        assert_encodes(-1.25_f32, Float(-1.25));
865    }
866
867    #[test]
868    fn serialize_f64() {
869        assert_encodes_to_float_satisfying(f64::NAN, |f| f.is_nan());
870        assert_encodes_to_float_satisfying(f64::INFINITY, |f| {
871            f.is_sign_positive() && f.is_infinite()
872        });
873        assert_encodes_to_float_satisfying(f64::NEG_INFINITY, |f| {
874            f.is_sign_negative() && f.is_infinite()
875        });
876        assert_encodes(1.25e67_f64, Float(1.25e67));
877        assert_encodes(-1.25e-67_f64, Float(-1.25e-67));
878    }
879
880    #[test]
881    fn serialize_char() {
882        assert_encodes('a', String(b"a".to_vec()));
883        assert_encodes('あ', String("あ".to_bytes()));
884    }
885
886    #[test]
887    fn serialize_str() {
888        assert_encodes("", String("".to_bytes()));
889        assert_encodes("x", String("x".to_bytes()));
890        assert_encodes("こんにちは世界", String("こんにちは世界".to_bytes()));
891        assert_encodes("Привет, мир!", String("Привет, мир!".to_bytes()));
892    }
893
894    #[test]
895    fn serialize_bytes() {
896        assert_encodes_to_bytes(b"", String("".to_bytes()));
897        assert_encodes_to_bytes(b"1", String("1".to_bytes()));
898        assert_encodes_to_bytes(b"Hello, world!", String("Hello, world!".to_bytes()));
899    }
900
901    #[test]
902    fn serialize_none() {
903        assert_encodes(Option::<i32>::None, Nil);
904    }
905
906    #[test]
907    fn serialize_some() {
908        assert_encodes(Some(true), Bool(true));
909        assert_encodes(Some(123), Int(123));
910    }
911
912    #[test]
913    fn serialize_unit() {
914        assert_encodes((), Nil);
915    }
916
917    #[test]
918    fn serialize_unit_struct() {
919        #[derive(Debug, Serialize)]
920        struct S;
921
922        assert_encodes(S, Nil);
923    }
924
925    #[test]
926    fn serialize_unit_variant() {
927        #[derive(Debug, Serialize)]
928        enum E {
929            A,
930            B,
931            C,
932        }
933
934        assert_encodes(E::A, String(b"A".to_vec()));
935        assert_encodes(E::B, String(b"B".to_vec()));
936        assert_encodes(E::C, String(b"C".to_vec()));
937    }
938
939    #[test]
940    fn serialize_newtype_struct() {
941        #[derive(Debug, Serialize)]
942        struct S(i64);
943
944        assert_encodes(S(123), object![S: Int(123)])
945    }
946
947    #[test]
948    fn serialize_newtype_variant() {
949        #[derive(Debug, Serialize)]
950        enum E {
951            A(bool),
952        }
953
954        assert_encodes(E::A(false), object![A: Bool(false)]);
955    }
956
957    #[test]
958    fn serialize_seq() {
959        assert_encodes(vec![1, 2, 3], array![Int(1), Int(2), Int(3)]);
960    }
961
962    #[test]
963    fn serialize_tuple() {
964        assert_encodes(
965            (1, true, vec![2_u8, 3_u8]),
966            array![Int(1), Bool(true), array![Uint(2), Uint(3)]],
967        );
968    }
969
970    #[test]
971    fn serialize_tuple_struct() {
972        #[derive(Debug, Serialize)]
973        struct T(i32, bool, &'static str);
974
975        assert_encodes(
976            T(123, true, "foo"),
977            array![Int(123), Bool(true), String(b"foo".to_vec())],
978        );
979    }
980
981    #[test]
982    fn serialize_tuple_variant() {
983        #[derive(Debug, Serialize)]
984        enum E {
985            A(i32, bool),
986            B(u64, ()),
987        }
988
989        assert_encodes(E::A(123, true), object![A: array![Int(123), Bool(true)]]);
990        assert_encodes(E::B(456, ()), object![B: array![Uint(456), Nil]]);
991    }
992
993    #[test]
994    fn serialize_map_key_bool() {
995        type HM<T> = std::collections::HashMap<bool, T>;
996
997        assert_encodes(HM::<i32>::new(), object![]);
998        assert_encodes(
999            [(true, "true"), (false, "false")]
1000                .into_iter()
1001                .collect::<HM<&'static str>>(),
1002            object![
1003                [b"\x01"]: String(b"true".to_vec()),
1004                [b"\x00"]: String(b"false".to_vec()),
1005            ],
1006        )
1007    }
1008
1009    #[test]
1010    fn serialize_map_key_i8() {
1011        type HM<T> = std::collections::HashMap<i8, T>;
1012
1013        assert_encodes(HM::<i32>::new(), object![]);
1014        assert_encodes(
1015            [(0, "A"), (0x7f, "B"), (-0x80, "C")]
1016                .into_iter()
1017                .collect::<HM<&'static str>>(),
1018            object![
1019                [b"\x00"]: String(b"A".to_vec()),
1020                [b"\x7f"]: String(b"B".to_vec()),
1021                [b"\x80"]: String(b"C".to_vec()),
1022            ],
1023        )
1024    }
1025
1026    #[test]
1027    fn serialize_map_key_i16() {
1028        type HM<T> = std::collections::HashMap<i16, T>;
1029
1030        assert_encodes(HM::<i32>::new(), object![]);
1031        assert_encodes(
1032            [(0, "A"), (0x7fff, "B"), (-0x8000, "C")]
1033                .into_iter()
1034                .collect::<HM<&'static str>>(),
1035            object![
1036                [b"\x00\x00"]: String(b"A".to_vec()),
1037                [b"\x7f\xff"]: String(b"B".to_vec()),
1038                [b"\x80\x00"]: String(b"C".to_vec()),
1039            ],
1040        )
1041    }
1042
1043    #[test]
1044    fn serialize_map_key_i32() {
1045        type HM<T> = std::collections::HashMap<i32, T>;
1046
1047        assert_encodes(HM::<i32>::new(), object![]);
1048        assert_encodes(
1049            [(0, "A"), (0x7fff_ffff, "B"), (-0x8000_0000, "C")]
1050                .into_iter()
1051                .collect::<HM<&'static str>>(),
1052            object![
1053                [b"\x00\x00\x00\x00"]: String(b"A".to_vec()),
1054                [b"\x7f\xff\xff\xff"]: String(b"B".to_vec()),
1055                [b"\x80\x00\x00\x00"]: String(b"C".to_vec()),
1056            ],
1057        )
1058    }
1059
1060    #[test]
1061    fn serialize_map_key_i64() {
1062        type HM<T> = std::collections::HashMap<i64, T>;
1063
1064        assert_encodes(HM::<i32>::new(), object![]);
1065        assert_encodes(
1066            [
1067                (0, "A"),
1068                (0x7fff_ffff_ffff_ffff, "B"),
1069                (-0x8000_0000_0000_0000, "C"),
1070            ]
1071            .into_iter()
1072            .collect::<HM<&'static str>>(),
1073            object![
1074                [b"\x00\x00\x00\x00\x00\x00\x00\x00"]: String(b"A".to_vec()),
1075                [b"\x7f\xff\xff\xff\xff\xff\xff\xff"]: String(b"B".to_vec()),
1076                [b"\x80\x00\x00\x00\x00\x00\x00\x00"]: String(b"C".to_vec()),
1077            ],
1078        )
1079    }
1080
1081    #[test]
1082    fn serialize_map_key_u8() {
1083        type HM<T> = std::collections::HashMap<u8, T>;
1084
1085        assert_encodes(HM::<i32>::new(), object![]);
1086        assert_encodes(
1087            [(0, "A"), (0x7f, "B"), (0xff, "C")]
1088                .into_iter()
1089                .collect::<HM<&'static str>>(),
1090            object![
1091                [b"\x00"]: String(b"A".to_vec()),
1092                [b"\x7f"]: String(b"B".to_vec()),
1093                [b"\xff"]: String(b"C".to_vec()),
1094            ],
1095        )
1096    }
1097
1098    #[test]
1099    fn serialize_map_key_u16() {
1100        type HM<T> = std::collections::HashMap<u16, T>;
1101
1102        assert_encodes(HM::<i32>::new(), object![]);
1103        assert_encodes(
1104            [(0, "A"), (0x7fff, "B"), (0xffff, "C")]
1105                .into_iter()
1106                .collect::<HM<&'static str>>(),
1107            object![
1108                [b"\x00\x00"]: String(b"A".to_vec()),
1109                [b"\x7f\xff"]: String(b"B".to_vec()),
1110                [b"\xff\xff"]: String(b"C".to_vec()),
1111            ],
1112        )
1113    }
1114
1115    #[test]
1116    fn serialize_map_key_u32() {
1117        type HM<T> = std::collections::HashMap<u32, T>;
1118
1119        assert_encodes(HM::<i32>::new(), object![]);
1120        assert_encodes(
1121            [(0, "A"), (0x7fff_ffff, "B"), (0xffff_ffff, "C")]
1122                .into_iter()
1123                .collect::<HM<&'static str>>(),
1124            object![
1125                [b"\x00\x00\x00\x00"]: String(b"A".to_vec()),
1126                [b"\x7f\xff\xff\xff"]: String(b"B".to_vec()),
1127                [b"\xff\xff\xff\xff"]: String(b"C".to_vec()),
1128            ],
1129        )
1130    }
1131
1132    #[test]
1133    fn serialize_map_key_u64() {
1134        type HM<T> = std::collections::HashMap<u64, T>;
1135
1136        assert_encodes(HM::<i32>::new(), object![]);
1137        assert_encodes(
1138            [
1139                (0, "A"),
1140                (0x7fff_ffff_ffff_ffff, "B"),
1141                (0xffff_ffff_ffff_ffff, "C"),
1142            ]
1143            .into_iter()
1144            .collect::<HM<&'static str>>(),
1145            object![
1146                [b"\x00\x00\x00\x00\x00\x00\x00\x00"]: String(b"A".to_vec()),
1147                [b"\x7f\xff\xff\xff\xff\xff\xff\xff"]: String(b"B".to_vec()),
1148                [b"\xff\xff\xff\xff\xff\xff\xff\xff"]: String(b"C".to_vec()),
1149            ],
1150        )
1151    }
1152
1153    #[test]
1154    fn serialize_map_key_char() {
1155        type HM<T> = std::collections::HashMap<char, T>;
1156
1157        assert_encodes(HM::<i32>::new(), object![]);
1158        assert_encodes(
1159            [('A', 1), ('B', 2), ('参', 3)]
1160                .into_iter()
1161                .collect::<HM<i32>>(),
1162            object![
1163                [b"A"]: Int(1),
1164                [b"B"]: Int(2),
1165                [b"\xe5\x8f\x82"]: Int(3),
1166            ],
1167        );
1168    }
1169
1170    #[test]
1171    fn serialize_map_key_str() {
1172        type HM<T> = std::collections::HashMap<&'static str, T>;
1173
1174        assert_encodes(HM::<i32>::new(), object![]);
1175        assert_encodes(
1176            [("foo", "bar")].into_iter().collect::<HM<&'static str>>(),
1177            object![foo: String(b"bar".to_vec())],
1178        );
1179        assert_encodes(
1180            [("foo", 123), ("bar", 456), ("", 789)]
1181                .into_iter()
1182                .collect::<HM<i32>>(),
1183            object![foo: Int(123), bar: Int(456), [b""]: Int(789)],
1184        );
1185    }
1186
1187    #[test]
1188    fn serialize_map_key_bytes() {
1189        type HM<T> = std::collections::HashMap<Vec<u8>, T>;
1190
1191        assert_encodes(HM::<i32>::new(), object![]);
1192        assert_encodes(
1193            [("foo".to_bytes(), "bar")]
1194                .into_iter()
1195                .collect::<HM<&'static str>>(),
1196            object![foo: String(b"bar".to_vec())],
1197        );
1198        assert_encodes(
1199            [
1200                ("foo".to_bytes(), 123),
1201                ("bar".to_bytes(), 456),
1202                ("".to_bytes(), 789),
1203            ]
1204            .into_iter()
1205            .collect::<HM<i32>>(),
1206            object![foo: Int(123), bar: Int(456), [b""]: Int(789)],
1207        );
1208    }
1209
1210    #[test]
1211    fn serialize_map_key_unit_variant() {
1212        #[derive(Eq, PartialEq, Hash, Debug, Serialize)]
1213        enum Key {
1214            A,
1215            B,
1216        }
1217        type HM<T> = std::collections::HashMap<Key, T>;
1218
1219        assert_encodes(
1220            [(Key::A, 123), (Key::B, 456)]
1221                .into_iter()
1222                .collect::<HM<i32>>(),
1223            object![A: Int(123), B: Int(456)],
1224        );
1225    }
1226
1227    #[test]
1228    fn serialize_map_key_newtype_struct() {
1229        #[derive(Eq, PartialEq, Hash, Debug, Serialize)]
1230        struct Key(&'static str);
1231        type HM<T> = std::collections::HashMap<Key, T>;
1232
1233        assert_encodes(
1234            [(Key("foo"), 123), (Key("bar"), 456)]
1235                .into_iter()
1236                .collect::<HM<i32>>(),
1237            object![foo: Int(123), bar: Int(456)],
1238        );
1239    }
1240
1241    #[test]
1242    fn serialize_struct() {
1243        #[derive(Debug, Serialize)]
1244        struct S {
1245            f1: i32,
1246            f2: &'static str,
1247            f3: bool,
1248        }
1249
1250        assert_encodes(
1251            S {
1252                f1: 123,
1253                f2: "abc",
1254                f3: true,
1255            },
1256            object![f1: Int(123), f2: String(b"abc".to_vec()), f3: Bool(true)],
1257        )
1258    }
1259
1260    #[test]
1261    fn serialize_struct_variant() {
1262        #[derive(Debug, Serialize)]
1263        enum E {
1264            S { f1: u32, f2: i32 },
1265        }
1266
1267        assert_encodes(
1268            E::S { f1: 123, f2: 456 },
1269            object![S: object![f1: Uint(123), f2: Int(456)]],
1270        );
1271    }
1272
1273    /*
1274     * Helper functions
1275     */
1276
1277    fn assert_encodes<T>(x: T, expected: watson_rs::Value)
1278    where
1279        T: fmt::Debug + ser::Serialize,
1280    {
1281        let actual = encode_then_decode(x);
1282        assert_eq!(actual, expected);
1283    }
1284
1285    fn assert_encodes_to_float_satisfying<T, F>(x: T, pred: F)
1286    where
1287        T: fmt::Debug + ser::Serialize,
1288        F: FnOnce(f64) -> bool,
1289    {
1290        match encode_then_decode(x) {
1291            Float(f) => {
1292                assert!(pred(f));
1293            }
1294            actual => {
1295                panic!("expected float but got {:?}", actual);
1296            }
1297        }
1298    }
1299
1300    fn assert_encodes_to_bytes(s: &[u8], expected: watson_rs::Value) {
1301        let mut buf = vec![];
1302        let mut ser = Serializer::new(&mut buf);
1303        ser.serialize_bytes(s).expect("serialization error");
1304        assert_eq!(decode(&mut buf.into_iter()), expected);
1305    }
1306
1307    fn encode_then_decode<T>(x: T) -> watson_rs::Value
1308    where
1309        T: ser::Serialize,
1310    {
1311        let mut buf = vec![];
1312        let mut ser = Serializer::new(&mut buf);
1313
1314        x.serialize(&mut ser).expect("selialization error");
1315
1316        decode(&mut buf.into_iter())
1317    }
1318
1319    fn decode<It>(it: &mut It) -> watson_rs::Value
1320    where
1321        It: Iterator<Item = watson_rs::Insn>,
1322    {
1323        let mut vm = watson_rs::VM::new();
1324        vm.execute_all(watson_rs::vm::SliceTokenReader::new(
1325            &it.collect::<Vec<watson_rs::Insn>>(),
1326        ))
1327        .expect("execution error");
1328        vm.peek_top().expect("stack should not be empty").clone()
1329    }
1330}
serde_watson/ser.rs

serde_watson/
ser.rs
