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

messagepack_serde/ser/
mod.rs
