messagepack_serde/ser/
mod.rs

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

messagepack_serde/ser/
mod.rs
