serde_hessian/
ser.rs

1use crate::error::Error;
2use hessian_rs::{ser::Serializer as ValueSerializer, value::Definition};
3
4use serde::{ser, Serialize};
5use std::io;
6
7type Result<T> = std::result::Result<T, Error>;
8
9pub struct Serializer<W: io::Write>(ValueSerializer<W>);
10
11impl<W: io::Write> Serializer<W> {
12    pub fn new(writer: W) -> Self {
13        Serializer(ValueSerializer::new(writer))
14    }
15}
16
17pub struct StructSerializer<'a, W: io::Write> {
18    name: &'static str,
19    ser: &'a mut Serializer<W>,
20    fields: Vec<&'a str>,
21    inx: usize,
22    buf: Vec<u8>,
23}
24
25pub struct MapSerializer<'a, W: io::Write> {
26    name: Option<&'static str>,
27    encoder: &'a mut Serializer<W>,
28}
29
30pub struct ListSerializer<'a, W: io::Write> {
31    ser: &'a mut Serializer<W>,
32    sized: bool,
33}
34
35impl<'a, W> StructSerializer<'a, W>
36where
37    W: io::Write,
38{
39    pub fn new(name: &'static str, ser: &'a mut Serializer<W>) -> Self {
40        StructSerializer {
41            name,
42            ser,
43            fields: Vec::new(),
44            inx: 0,
45            buf: Vec::new(),
46        }
47    }
48}
49
50impl<'a, W: io::Write> ser::SerializeStruct for StructSerializer<'a, W> {
51    type Ok = ();
52    type Error = Error;
53
54    fn serialize_field<U: Serialize + ?Sized>(
55        &mut self,
56        key: &'static str,
57        value: &U,
58    ) -> Result<()> {
59        if let Some(definition) = self.ser.0.get_definition(self.name) {
60            if key != definition.fields[self.inx] {
61                return Err(Error::SyntaxError(hessian_rs::ErrorKind::UnexpectedType(
62                    "field name mismatch".to_string(),
63                )));
64            }
65            self.inx += 1;
66        } else {
67            self.fields.push(key);
68        }
69        value.serialize(&mut Serializer::new(&mut self.buf))?;
70        Ok(())
71    }
72
73    #[inline]
74    fn end(self) -> Result<()> {
75        let def = match self.ser.0.get_definition(self.name) {
76            Some(def) => def.clone(),
77            None => {
78                let def = Definition {
79                    name: self.name.into(),
80                    fields: self.fields.iter().map(|v| v.to_string()).collect(),
81                };
82                self.ser.0.write_definition(&def)?;
83                def
84            }
85        };
86        self.ser.0.write_object_start(&def)?;
87        self.ser.0.extend_from_slice(&self.buf)?;
88        Ok(())
89    }
90}
91
92impl<'a, W: io::Write> ser::SerializeSeq for ListSerializer<'a, W> {
93    type Ok = ();
94    type Error = Error;
95
96    #[inline]
97    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
98        value.serialize(&mut *self.ser)?;
99        Ok(())
100    }
101
102    #[inline]
103    fn end(self) -> Result<()> {
104        Ok(())
105    }
106}
107
108impl<'a, W: io::Write> ser::SerializeTuple for ListSerializer<'a, W> {
109    type Ok = ();
110    type Error = Error;
111
112    #[inline]
113    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
114        value.serialize(&mut *self.ser)?;
115        Ok(())
116    }
117
118    #[inline]
119    fn end(self) -> Result<()> {
120        if !self.sized {
121            self.ser.0.write_object_end()?;
122        }
123        Ok(())
124    }
125}
126
127impl<'a, W: io::Write> ser::SerializeTupleStruct for ListSerializer<'a, W> {
128    type Ok = ();
129    type Error = Error;
130
131    #[inline]
132    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
133        ser::SerializeTuple::serialize_element(self, value)
134    }
135
136    #[inline]
137    fn end(self) -> Result<()> {
138        Ok(())
139    }
140}
141
142impl<'a, W: io::Write> ser::SerializeTupleVariant for ListSerializer<'a, W> {
143    type Ok = ();
144    type Error = Error;
145
146    #[inline]
147    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
148        ser::SerializeTuple::serialize_element(self, value)
149    }
150
151    #[inline]
152    fn end(self) -> Result<()> {
153        Ok(())
154    }
155}
156
157impl<'a, W: io::Write> ser::SerializeMap for MapSerializer<'a, W> {
158    type Ok = ();
159    type Error = Error;
160
161    #[inline]
162    fn serialize_key<T: Serialize + ?Sized>(&mut self, key: &T) -> Result<()> {
163        key.serialize(&mut *self.encoder)
164    }
165
166    #[inline]
167    fn serialize_value<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
168        value.serialize(&mut *self.encoder)
169    }
170
171    #[inline]
172    fn serialize_entry<K: ?Sized, V: ?Sized>(
173        &mut self,
174        key: &K,
175        value: &V,
176    ) -> std::result::Result<(), Self::Error>
177    where
178        K: Serialize,
179        V: Serialize,
180    {
181        key.serialize(&mut *self.encoder)?;
182        value.serialize(&mut *self.encoder)
183    }
184
185    #[inline]
186    fn end(self) -> Result<()> {
187        self.encoder.0.write_object_end()?;
188        Ok(())
189    }
190}
191
192impl<'a, W: io::Write> ser::SerializeStruct for MapSerializer<'a, W> {
193    type Ok = ();
194    type Error = Error;
195
196    fn serialize_field<T: Serialize + ?Sized>(
197        &mut self,
198        key: &'static str,
199        value: &T,
200    ) -> Result<()> {
201        ser::SerializeMap::serialize_key(self, key)?;
202        ser::SerializeMap::serialize_value(self, value)
203    }
204
205    #[inline]
206    fn end(self) -> Result<()> {
207        self.encoder.0.write_object_end()?;
208        Ok(())
209    }
210}
211
212impl<'a, W: io::Write> ser::SerializeStructVariant for MapSerializer<'a, W> {
213    type Ok = ();
214    type Error = Error;
215
216    #[inline]
217    fn serialize_field<T: Serialize + ?Sized>(
218        &mut self,
219        key: &'static str,
220        value: &T,
221    ) -> Result<()> {
222        ser::SerializeMap::serialize_key(self, key)?;
223        ser::SerializeMap::serialize_value(self, value)
224    }
225
226    #[inline]
227    fn end(self) -> Result<()> {
228        self.encoder.0.write_object_end()?;
229        Ok(())
230    }
231}
232
233impl<'a, W: io::Write> ser::Serializer for &'a mut Serializer<W> {
234    type Ok = ();
235    type Error = Error;
236
237    type SerializeSeq = ListSerializer<'a, W>;
238    type SerializeTuple = Self::SerializeSeq;
239    type SerializeTupleStruct = Self::SerializeTuple;
240    type SerializeTupleVariant = Self::SerializeTuple;
241    type SerializeMap = MapSerializer<'a, W>;
242    type SerializeStruct = StructSerializer<'a, W>;
243    type SerializeStructVariant = Self::SerializeMap;
244
245    #[inline]
246    fn serialize_bool(self, value: bool) -> Result<()> {
247        self.0.serialize_bool(value)?;
248        Ok(())
249    }
250
251    #[inline]
252    fn serialize_i8(self, value: i8) -> Result<()> {
253        self.0.serialize_int(value as i32)?;
254        Ok(())
255    }
256
257    #[inline]
258    fn serialize_i16(self, value: i16) -> Result<()> {
259        self.0.serialize_int(value as i32)?;
260        Ok(())
261    }
262
263    #[inline]
264    fn serialize_i32(self, value: i32) -> Result<()> {
265        self.0.serialize_int(value)?;
266        Ok(())
267    }
268
269    #[inline]
270    fn serialize_i64(self, value: i64) -> Result<()> {
271        self.0.serialize_long(value)?;
272        Ok(())
273    }
274
275    #[inline]
276    fn serialize_u8(self, value: u8) -> Result<()> {
277        self.0.serialize_int(value as i32)?;
278        Ok(())
279    }
280
281    #[inline]
282    fn serialize_u16(self, value: u16) -> Result<()> {
283        self.0.serialize_int(value as i32)?;
284        Ok(())
285    }
286
287    #[inline]
288    fn serialize_u32(self, value: u32) -> Result<()> {
289        if value < i32::max_value() as u32 {
290            self.0.serialize_int(value as i32)?;
291        } else {
292            self.0.serialize_long(value as i64)?;
293        }
294        Ok(())
295    }
296
297    #[inline]
298    fn serialize_u64(self, value: u64) -> Result<()> {
299        self.0.serialize_long(value as i64)?;
300        Ok(())
301    }
302
303    #[inline]
304    fn serialize_f32(self, value: f32) -> Result<()> {
305        self.0.serialize_double(value as f64)?;
306        Ok(())
307    }
308
309    #[inline]
310    fn serialize_f64(self, value: f64) -> Result<()> {
311        self.0.serialize_double(value)?;
312        Ok(())
313    }
314
315    #[inline]
316    fn serialize_char(self, value: char) -> Result<()> {
317        let mut buf = [0; 4];
318        self.0.serialize_string(value.encode_utf8(&mut buf))?;
319        Ok(())
320    }
321
322    #[inline]
323    fn serialize_str(self, value: &str) -> Result<()> {
324        self.0.serialize_string(value)?;
325        Ok(())
326    }
327
328    #[inline]
329    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
330        self.0.serialize_binary(value)?;
331        Ok(())
332    }
333
334    #[inline]
335    fn serialize_unit(self) -> Result<()> {
336        self.0.serialize_null()?;
337        Ok(())
338    }
339
340    #[inline]
341    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
342        self.0.serialize_null()?;
343        Ok(())
344    }
345
346    #[inline]
347    fn serialize_unit_variant(
348        self,
349        _name: &'static str,
350        _variant_index: u32,
351        variant: &'static str,
352    ) -> Result<()> {
353        self.serialize_str(variant)
354    }
355
356    #[inline]
357    fn serialize_newtype_struct<T: Serialize + ?Sized>(
358        self,
359        _name: &'static str,
360        value: &T,
361    ) -> Result<()> {
362        value.serialize(self)
363    }
364
365    #[inline]
366    fn serialize_newtype_variant<T: Serialize + ?Sized>(
367        self,
368        _name: &'static str,
369        _variant_index: u32,
370        _variant: &'static str,
371        value: &T,
372    ) -> Result<()> {
373        value.serialize(self)
374    }
375
376    #[inline]
377    fn serialize_none(self) -> Result<()> {
378        self.serialize_unit()
379    }
380
381    #[inline]
382    fn serialize_some<T: Serialize + ?Sized>(self, value: &T) -> Result<()> {
383        value.serialize(self)
384    }
385
386    #[inline]
387    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
388        match len {
389            Some(len) => {
390                self.0.write_list_begin(len, None)?;
391                Ok(ListSerializer {
392                    ser: self,
393                    sized: true,
394                })
395            }
396            None => Ok(ListSerializer {
397                ser: self,
398                sized: false,
399            }),
400        }
401    }
402
403    #[inline]
404    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
405        self.0.write_list_begin(len, None)?;
406        Ok(ListSerializer {
407            ser: self,
408            sized: true,
409        })
410    }
411
412    #[inline]
413    fn serialize_tuple_struct(
414        self,
415        name: &'static str,
416        len: usize,
417    ) -> Result<Self::SerializeTupleStruct> {
418        self.0.write_list_begin(len, Some(name))?;
419        Ok(ListSerializer {
420            ser: self,
421            sized: true,
422        })
423    }
424
425    #[inline]
426    fn serialize_tuple_variant(
427        self,
428        name: &'static str,
429        _variant_index: u32,
430        variant: &'static str,
431        len: usize,
432    ) -> Result<Self::SerializeTupleVariant> {
433        self.0
434            .write_list_begin(len, Some(&format!("{}.{}", name, variant)))?;
435        Ok(ListSerializer {
436            ser: self,
437            sized: true,
438        })
439    }
440
441    #[inline]
442    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
443        self.0.write_map_start(None)?;
444        Ok(MapSerializer {
445            name: None,
446            encoder: self,
447        })
448    }
449
450    #[inline]
451    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
452        Ok(StructSerializer::new(name, self))
453    }
454
455    #[inline]
456    fn serialize_struct_variant(
457        self,
458        name: &'static str,
459        _variant_index: u32,
460        variant: &'static str,
461        _len: usize,
462    ) -> Result<Self::SerializeStructVariant> {
463        self.0.write_map_start(Some(variant))?;
464        Ok(MapSerializer {
465            name: Some(name),
466            encoder: self,
467        })
468    }
469
470    fn serialize_i128(self, v: i128) -> std::result::Result<Self::Ok, Self::Error> {
471        let _ = v;
472        Err(ser::Error::custom("i128 is not supported"))
473    }
474
475    fn serialize_u128(self, v: u128) -> std::result::Result<Self::Ok, Self::Error> {
476        let _ = v;
477        Err(ser::Error::custom("u128 is not supported"))
478    }
479
480    fn collect_str<T: ?Sized>(self, value: &T) -> std::result::Result<Self::Ok, Self::Error>
481    where
482        T: std::fmt::Display,
483    {
484        self.serialize_str(&value.to_string())
485    }
486
487    fn is_human_readable(&self) -> bool {
488        false
489    }
490}
491
492pub fn to_vec<T>(value: &T) -> Result<Vec<u8>>
493where
494    T: Serialize,
495{
496    let mut buf = Vec::new();
497    let mut ser = Serializer::new(&mut buf);
498    value.serialize(&mut ser)?;
499    Ok(buf)
500}
501
502#[cfg(test)]
503mod test {
504    use crate::ser::to_vec;
505    use serde::Serialize;
506
507    #[test]
508    fn test_struct() {
509        {
510            #[derive(Serialize)]
511            #[serde(rename = "example.Car")]
512            struct Car {
513                color: String,
514                model: String,
515            }
516            let output = to_vec(&Car {
517                color: "red".to_string(),
518                model: "Ferrari".to_string(),
519            })
520            .unwrap();
521            assert_eq!(
522                output,
523                &[
524                    b'C', 0x0b, b'e', b'x', b'a', b'm', b'p', b'l', b'e', b'.', b'C', b'a', b'r',
525                    0x92, 0x05, b'c', b'o', b'l', b'o', b'r', 0x05, b'm', b'o', b'd', b'e', b'l',
526                    b'O', 0x90, 0x03, b'r', b'e', b'd', 0x07, b'F', b'e', b'r', b'r', b'a', b'r',
527                    b'i',
528                ]
529            );
530        }
531        #[derive(Serialize)]
532        struct Test {
533            int: u32,
534            seq: Vec<&'static str>,
535        }
536
537        let test = Test {
538            int: 1,
539            seq: vec!["a", "b"],
540        };
541        let output = to_vec(&test).unwrap();
542        assert_eq!(
543            output,
544            &[
545                b'C', 0x04, b'T', b'e', b's', b't', 0x92, 0x03, b'i', b'n', b't', 0x03, b's', b'e',
546                b'q', b'O', 0x90, 0x91, 0x7a, 0x01, b'a', 0x01, b'b'
547            ]
548        )
549    }
550
551    // todo: how keep consistence with java class?
552    #[test]
553    fn test_enum() {
554        #[derive(Serialize)]
555        enum E {
556            Unit,
557            Newtype(u32),
558            Tuple(u32, u32),
559            Struct { a: u32 },
560        }
561
562        let u = E::Unit;
563        let expected = b"\x04Unit";
564        assert_eq!(to_vec(&u).unwrap(), expected);
565
566        let n = E::Newtype(1);
567        assert_eq!(to_vec(&n).unwrap(), &[0x91]);
568
569        // serialize tuple variant, use variant as list name
570        let t = E::Tuple(1, 2);
571        assert_eq!(
572            to_vec(&t).unwrap(),
573            &[0x72, 0x07, b'E', b'.', b'T', b'u', b'p', b'l', b'e', 0x91, 0x92]
574        );
575
576        // serialize Variant Struct, use variant naeme as map name
577        let s = E::Struct { a: 1 };
578        assert_eq!(
579            to_vec(&s).unwrap(),
580            &[b'M', 0x06, b'S', b't', b'r', b'u', b'c', b't', 0x01, b'a', 0x91, b'Z']
581        );
582    }
583}
serde_hessian/ser.rs

serde_hessian/
ser.rs
