messagepack_serde/ser/
mod.rs

1mod error;
2mod map;
3mod num;
4mod seq;
5pub use num::{AggressiveMinimize, Exact, LosslessMinimize, NumEncoder};
6
7use core::marker::PhantomData;
8
9use crate::value::extension::{EXTENSION_STRUCT_NAME, SerializeExt};
10pub use error::{CoreError, Error};
11use messagepack_core::{
12    Encode, SliceWriter,
13    encode::{ArrayFormatEncoder, BinaryEncoder, MapFormatEncoder, NilEncoder},
14    io::{IoWrite, WError},
15};
16
17use serde::ser;
18
19#[derive(Debug, PartialOrd, Ord, PartialEq, Eq)]
20pub struct Serializer<'a, W, Num> {
21    writer: &'a mut W,
22    current_length: usize,
23    num_encoder: PhantomData<Num>,
24}
25
26impl<'a, W, Num> Serializer<'a, W, Num>
27where
28    W: IoWrite,
29    Num: num::NumEncoder<W>,
30{
31    pub fn new(writer: &'a mut W, _num_encoder: Num) -> Self {
32        Self {
33            writer,
34            current_length: 0,
35            num_encoder: PhantomData,
36        }
37    }
38}
39
40impl<W, Num> AsMut<Self> for Serializer<'_, W, Num> {
41    fn as_mut(&mut self) -> &mut Self {
42        self
43    }
44}
45
46pub fn to_slice<T>(value: &T, buf: &mut [u8]) -> Result<usize, Error<WError>>
47where
48    T: ser::Serialize + ?Sized,
49{
50    to_slice_with_config(value, buf, num::Exact)
51}
52
53pub fn to_slice_with_config<'a, T, C>(
54    value: &T,
55    buf: &'a mut [u8],
56    config: C,
57) -> Result<usize, Error<WError>>
58where
59    T: ser::Serialize + ?Sized,
60    C: NumEncoder<SliceWriter<'a>>,
61{
62    let mut writer = SliceWriter::from_slice(buf);
63    let mut ser = Serializer::new(&mut writer, config);
64    value.serialize(&mut ser)?;
65    Ok(ser.current_length)
66}
67
68#[cfg(feature = "std")]
69pub fn to_writer<T, W>(value: &T, writer: &mut W) -> Result<usize, Error<std::io::Error>>
70where
71    T: ser::Serialize + ?Sized,
72    W: std::io::Write,
73{
74    to_writer_with_config(value, writer, num::Exact)
75}
76
77#[cfg(feature = "std")]
78pub fn to_writer_with_config<T, W, C>(
79    value: &T,
80    writer: &mut W,
81    config: C,
82) -> Result<usize, Error<std::io::Error>>
83where
84    T: ser::Serialize + ?Sized,
85    W: std::io::Write,
86    C: NumEncoder<W>,
87{
88    let mut ser = Serializer::new(writer, config);
89    value.serialize(&mut ser)?;
90    Ok(ser.current_length)
91}
92
93#[cfg(feature = "std")]
94pub fn to_vec<T>(value: &T) -> Result<Vec<u8>, Error<std::io::Error>>
95where
96    T: ser::Serialize + ?Sized,
97{
98    let mut buf = Vec::new();
99
100    to_writer(value, &mut buf)?;
101    Ok(buf)
102}
103
104#[cfg(feature = "std")]
105pub fn to_vec_with_config<T, C>(value: &T, config: C) -> Result<Vec<u8>, Error<std::io::Error>>
106where
107    T: ser::Serialize + ?Sized,
108    C: NumEncoder<Vec<u8>>,
109{
110    let mut buf = Vec::new();
111
112    to_writer_with_config(value, &mut buf, config)?;
113    Ok(buf)
114}
115
116impl<'a, 'b: 'a, W, Num> ser::Serializer for &'a mut Serializer<'b, W, Num>
117where
118    W: IoWrite,
119    Num: NumEncoder<W>,
120{
121    type Ok = ();
122    type Error = Error<W::Error>;
123
124    type SerializeSeq = seq::SerializeSeq<'a, 'b, W, Num>;
125    type SerializeTuple = seq::SerializeSeq<'a, 'b, W, Num>;
126    type SerializeTupleStruct = seq::SerializeSeq<'a, 'b, W, Num>;
127    type SerializeTupleVariant = seq::SerializeSeq<'a, 'b, W, Num>;
128    type SerializeMap = map::SerializeMap<'a, 'b, W, Num>;
129    type SerializeStruct = map::SerializeMap<'a, 'b, W, Num>;
130    type SerializeStructVariant = map::SerializeMap<'a, 'b, W, Num>;
131
132    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
133        self.current_length += v.encode(self.writer)?;
134        Ok(())
135    }
136
137    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
138        self.current_length += Num::encode_i8(v, self.writer)?;
139        Ok(())
140    }
141
142    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
143        self.current_length += Num::encode_i16(v, self.writer)?;
144        Ok(())
145    }
146
147    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
148        self.current_length += Num::encode_i32(v, self.writer)?;
149        Ok(())
150    }
151
152    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
153        self.current_length += Num::encode_i64(v, self.writer)?;
154        Ok(())
155    }
156
157    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
158        self.current_length += Num::encode_i128(v, self.writer)?;
159        Ok(())
160    }
161
162    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
163        self.current_length += Num::encode_u8(v, self.writer)?;
164        Ok(())
165    }
166
167    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
168        self.current_length += Num::encode_u16(v, self.writer)?;
169        Ok(())
170    }
171
172    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
173        self.current_length += Num::encode_u32(v, self.writer)?;
174        Ok(())
175    }
176
177    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
178        self.current_length += Num::encode_u64(v, self.writer)?;
179        Ok(())
180    }
181
182    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
183        self.current_length += Num::encode_u128(v, self.writer)?;
184        Ok(())
185    }
186
187    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
188        self.current_length += Num::encode_f32(v, self.writer)?;
189        Ok(())
190    }
191
192    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
193        self.current_length += Num::encode_f64(v, self.writer)?;
194        Ok(())
195    }
196
197    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
198        // char takes max 4 bytes
199        let mut buf = [0u8; 4];
200        let s = v.encode_utf8(&mut buf);
201        self.serialize_str(s)
202    }
203
204    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
205        self.current_length += v.encode(self.writer)?;
206        Ok(())
207    }
208
209    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
210        self.current_length += BinaryEncoder(v).encode(self.writer)?;
211        Ok(())
212    }
213
214    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
215        self.current_length += NilEncoder.encode(self.writer)?;
216        Ok(())
217    }
218
219    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
220    where
221        T: ?Sized + ser::Serialize,
222    {
223        value.serialize(self)
224    }
225
226    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
227        self.serialize_none()
228    }
229
230    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
231        self.serialize_unit()
232    }
233
234    fn serialize_unit_variant(
235        self,
236        _name: &'static str,
237        _variant_index: u32,
238        variant: &'static str,
239    ) -> Result<Self::Ok, Self::Error> {
240        self.serialize_str(variant)
241    }
242
243    fn serialize_newtype_struct<T>(
244        self,
245        name: &'static str,
246        value: &T,
247    ) -> Result<Self::Ok, Self::Error>
248    where
249        T: ?Sized + ser::Serialize,
250    {
251        match name {
252            EXTENSION_STRUCT_NAME => {
253                let mut ser = SerializeExt::new(self.writer, &mut self.current_length);
254                value.serialize(&mut ser)
255            }
256            _ => value.serialize(self.as_mut()),
257        }
258    }
259
260    fn serialize_newtype_variant<T>(
261        self,
262        _name: &'static str,
263        _variant_index: u32,
264        variant: &'static str,
265        value: &T,
266    ) -> Result<Self::Ok, Self::Error>
267    where
268        T: ?Sized + ser::Serialize,
269    {
270        self.current_length += MapFormatEncoder::new(1).encode(self.writer)?;
271        self.serialize_str(variant)?;
272        value.serialize(self.as_mut())
273    }
274
275    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
276        let len = len.ok_or(Error::SeqLenNone)?;
277        self.current_length += ArrayFormatEncoder::new(len).encode(self.writer)?;
278        Ok(seq::SerializeSeq::new(self))
279    }
280
281    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
282        self.serialize_seq(Some(len))
283    }
284
285    fn serialize_tuple_struct(
286        self,
287        _name: &'static str,
288        len: usize,
289    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
290        self.serialize_seq(Some(len))
291    }
292
293    fn serialize_tuple_variant(
294        self,
295        _name: &'static str,
296        _variant_index: u32,
297        variant: &'static str,
298        len: usize,
299    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
300        self.current_length += MapFormatEncoder::new(1).encode(self.writer)?;
301        self.serialize_str(variant)?;
302        self.current_length += ArrayFormatEncoder::new(len).encode(self.writer)?;
303        Ok(seq::SerializeSeq::new(self))
304    }
305
306    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
307        let len = len.ok_or(Error::SeqLenNone)?;
308        self.current_length += MapFormatEncoder::new(len).encode(self.writer)?;
309        Ok(map::SerializeMap::new(self))
310    }
311
312    fn serialize_struct(
313        self,
314        _name: &'static str,
315        len: usize,
316    ) -> Result<Self::SerializeStruct, Self::Error> {
317        self.current_length += MapFormatEncoder::new(len).encode(self.writer)?;
318        Ok(map::SerializeMap::new(self))
319    }
320
321    fn serialize_struct_variant(
322        self,
323        name: &'static str,
324        _variant_index: u32,
325        variant: &'static str,
326        len: usize,
327    ) -> Result<Self::SerializeStructVariant, Self::Error> {
328        self.current_length += MapFormatEncoder::new(1).encode(self.writer)?;
329        self.serialize_str(variant)?;
330        self.serialize_struct(name, len)
331    }
332
333    fn is_human_readable(&self) -> bool {
334        false
335    }
336}
337
338#[cfg(test)]
339mod tests {
340    use serde::Serialize;
341
342    use super::*;
343
344    #[test]
345    fn encode_nil() {
346        let v: Option<()> = None;
347        let buf = &mut [0u8; 128];
348        let len = to_slice(&v, buf).unwrap();
349        assert_eq!(buf[..len], [0xc0]);
350    }
351
352    #[test]
353    fn encode_unit() {
354        let buf = &mut [0u8; 128];
355        let len = to_slice(&(), buf).unwrap();
356        assert_eq!(buf[..len], [0xc0]);
357    }
358
359    #[test]
360    fn encode_unit_struct() {
361        #[derive(Serialize)]
362        struct Unit;
363        let buf = &mut [0u8; 128];
364        let len = to_slice(&Unit, buf).unwrap();
365        assert_eq!(buf[..len], [0xc0]);
366    }
367
368    #[test]
369    fn encode_false() {
370        let v = false;
371        let buf = &mut [0u8; 128];
372        let len = to_slice(&v, buf).unwrap();
373        assert_eq!(buf[..len], [0xc2]);
374    }
375
376    #[test]
377    fn encode_true() {
378        let v = true;
379        let buf = &mut [0u8; 128];
380        let len = to_slice(&v, buf).unwrap();
381        assert_eq!(buf[..len], [0xc3]);
382    }
383
384    #[test]
385    fn encode_bytes() {
386        // default &[u8] not call serialize_bytes
387        let v = serde_bytes::Bytes::new(&[5, 4, 3, 2, 1, 0]);
388
389        let buf = &mut [0u8; 128];
390        let len = to_slice(&v, buf).unwrap();
391        assert_eq!(buf[..len], [0xc4, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00]);
392    }
393
394    #[test]
395    fn encode_enum() {
396        #[derive(Serialize)]
397        enum Type {
398            Bool,
399            Int,
400            Float,
401        }
402        let buf = &mut [0u8; 128];
403        {
404            let len = to_slice(&Type::Bool, buf).unwrap();
405            assert_eq!(buf[..len], [0xa4, b'B', b'o', b'o', b'l'])
406        }
407        {
408            let len = to_slice(&Type::Int, buf).unwrap();
409            assert_eq!(buf[..len], [0xa3, b'I', b'n', b't'])
410        }
411        {
412            let len = to_slice(&Type::Float, buf).unwrap();
413            assert_eq!(buf[..len], [0xa5, b'F', b'l', b'o', b'a', b't'])
414        }
415    }
416
417    #[test]
418    fn encode_newtype_struct() {
419        #[derive(Serialize)]
420        struct B(#[serde(with = "serde_bytes")] [u8; 5]);
421
422        let buf = &mut [0u8; 128];
423
424        let len = to_slice(&B([5, 4, 3, 2, 1]), buf).unwrap();
425        assert_eq!(buf[..len], [0xc4, 0x05, 0x05, 0x04, 0x03, 0x02, 0x01])
426    }
427
428    #[test]
429    fn encode_newtype_variant() {
430        #[derive(Serialize)]
431        enum Type {
432            Bool(bool),
433            Int(u8),
434            Float(f32),
435        }
436
437        let buf = &mut [0u8; 128];
438        {
439            let len = to_slice(&Type::Bool(true), buf).unwrap();
440            assert_eq!(
441                buf[..len],
442                [
443                    0x81, // fixmap len = 1
444                    0xa4, // fixstr len = 4
445                    b'B', b'o', b'o', b'l', 0xc3 // true
446                ]
447            )
448        }
449        {
450            let len = to_slice(&Type::Int(128), buf).unwrap();
451            assert_eq!(
452                buf[..len],
453                [
454                    0x81, // fixmap len = 1
455                    0xa3, b'I', b'n', b't', // fixstr "Int"
456                    0xcc, 0x80 // uint8 128
457                ]
458            )
459        }
460
461        {
462            let len = to_slice(&Type::Float(12.34), buf).unwrap();
463            assert_eq!(
464                buf[..len],
465                [
466                    0x81, // fixmap len = 1
467                    0xa5, b'F', b'l', b'o', b'a', b't', // fixstr "Float"
468                    0xca, 0x41, 0x45, 0x70, 0xa4 // float32 12.34
469                ]
470            )
471        }
472    }
473
474    #[test]
475    fn encode_struct_variant() {
476        #[derive(Serialize)]
477        enum Type {
478            Bool { flag: bool, msg: &'static str },
479        }
480
481        // expect
482        // {
483        //   "Bool":{
484        //       "flag": bool,
485        //       "msg": "Some message"
486        //    }
487        // }
488
489        let buf = &mut [0u8; 128];
490        {
491            let len = to_slice(
492                &Type::Bool {
493                    flag: false,
494                    msg: "hi",
495                },
496                buf,
497            )
498            .unwrap();
499            assert_eq!(
500                buf[..len],
501                [
502                    0x81, // fixmap len = 1
503                    0xa4, // fixstr len = 4
504                    b'B', b'o', b'o', b'l', // top
505                    0x82, // fixmap len = 2
506                    0xa4, // fixstr len = 4
507                    b'f', b'l', b'a', b'g', // key
508                    0xc2, // false
509                    0xa3, // fixstr len = 3
510                    b'm', b's', b'g', //key
511                    0xa2, // fixstr len = 2
512                    b'h', b'i',
513                ]
514            )
515        }
516    }
517
518    #[test]
519    fn encode_tuple_struct() {
520        #[derive(Serialize)]
521        struct V(i16, u32, i32);
522
523        let buf = &mut [0u8; 128];
524        let len = to_slice(&V(1, 2, 3), buf).unwrap();
525        assert_eq!(
526            buf[..len],
527            [
528                0x93, // fixarr len = 3
529                0xd1, 0x00, 0x01, // int16
530                0xce, 0x00, 0x00, 0x00, 0x02, // uint32
531                0xd2, 0x00, 0x00, 0x00, 0x03, // uint32
532            ]
533        );
534    }
535
536    #[test]
537    fn encode_pos_fix_int() {
538        let v = 127_u8;
539        let buf = &mut [0u8; 128];
540        let len = to_slice(&v, buf).unwrap();
541        assert_eq!(buf[..len], [0x7f]);
542    }
543
544    #[test]
545    fn encode_neg_fix_int() {
546        let v = -32_i8;
547        let buf = &mut [0u8; 128];
548        let len = to_slice(&v, buf).unwrap();
549        assert_eq!(buf[..len], [0xe0]);
550    }
551
552    #[test]
553    fn encode_extension() {
554        use crate::value::extension::ExtensionRef;
555        let kind: i8 = 123;
556        let ext = ExtensionRef::new(kind, &[0x12]);
557        let buf = &mut [0_u8; 3];
558
559        let len = to_slice(&ext, buf).unwrap();
560        assert_eq!(buf[..len], [0xd4, kind.to_be_bytes()[0], 0x12]);
561    }
562
563    #[cfg(feature = "std")]
564    #[test]
565    fn encode_with_writer() {
566        #[derive(Serialize)]
567        struct V(i16, u32, i32);
568
569        let mut buf = vec![];
570        let len = to_writer(&V(1, 2, 3), &mut buf).unwrap();
571        assert_eq!(
572            buf[..len],
573            [
574                0x93, // fixarr len = 3
575                0xd1, 0x00, 0x01, // int16
576                0xce, 0x00, 0x00, 0x00, 0x02, // uint32
577                0xd2, 0x00, 0x00, 0x00, 0x03, // uint32
578            ]
579        );
580    }
581}
messagepack_serde/ser/mod.rs

messagepack_serde/ser/
mod.rs
