messagepack_serde/value/
extension.rs

1use messagepack_core::{
2    Format,
3    extension::ExtensionRef as CoreExtensionRef,
4    io::{IoRead, IoWrite},
5};
6use serde::{
7    Serialize, Serializer,
8    de::Visitor,
9    ser::{self, SerializeSeq},
10};
11
12use crate::ser::Error;
13
14pub(crate) const EXTENSION_STRUCT_NAME: &str = "$__MSGPACK_EXTENSION_STRUCT";
15
16pub(crate) struct SerializeExt<'a, W> {
17    writer: &'a mut W,
18    length: usize,
19}
20
21impl<W> AsMut<Self> for SerializeExt<'_, W> {
22    fn as_mut(&mut self) -> &mut Self {
23        self
24    }
25}
26
27impl<'a, W> SerializeExt<'a, W> {
28    pub fn new(writer: &'a mut W) -> Self {
29        Self { writer, length: 0 }
30    }
31
32    pub(crate) fn length(&self) -> usize {
33        self.length
34    }
35}
36
37impl<W: IoWrite> SerializeExt<'_, W> {
38    fn unexpected(&self) -> Error<W::Error> {
39        ser::Error::custom("unexpected value")
40    }
41}
42
43impl<'a, 'b, W> ser::Serializer for &'a mut SerializeExt<'b, W>
44where
45    'b: 'a,
46    W: IoWrite,
47{
48    type Ok = ();
49
50    type Error = Error<W::Error>;
51
52    type SerializeSeq = SerializeExtSeq<'a, 'b, W>;
53
54    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
55
56    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
57
58    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
59
60    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
61
62    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
63
64    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
65
66    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
67        Err(self.unexpected())
68    }
69
70    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
71        self.serialize_bytes(&v.to_be_bytes())
72    }
73
74    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
75        Err(self.unexpected())
76    }
77
78    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
79        Err(self.unexpected())
80    }
81
82    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
83        Err(self.unexpected())
84    }
85
86    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
87        self.serialize_bytes(&v.to_be_bytes())
88    }
89
90    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
91        self.serialize_bytes(&v.to_be_bytes())
92    }
93
94    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
95        self.serialize_bytes(&v.to_be_bytes())
96    }
97
98    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
99        self.serialize_bytes(&v.to_be_bytes())
100    }
101
102    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
103        Err(self.unexpected())
104    }
105
106    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
107        Err(self.unexpected())
108    }
109
110    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
111        Err(self.unexpected())
112    }
113
114    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
115        Err(self.unexpected())
116    }
117
118    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
119        self.writer
120            .write(v)
121            .map_err(messagepack_core::encode::Error::Io)?;
122        self.length += v.len();
123        Ok(())
124    }
125
126    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
127        Err(self.unexpected())
128    }
129
130    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
131    where
132        T: ?Sized + Serialize,
133    {
134        Err(self.unexpected())
135    }
136
137    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
138        Err(self.unexpected())
139    }
140
141    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
142        Err(self.unexpected())
143    }
144
145    fn serialize_unit_variant(
146        self,
147        _name: &'static str,
148        _variant_index: u32,
149        _variant: &'static str,
150    ) -> Result<Self::Ok, Self::Error> {
151        Err(self.unexpected())
152    }
153
154    fn serialize_newtype_struct<T>(
155        self,
156        _name: &'static str,
157        value: &T,
158    ) -> Result<Self::Ok, Self::Error>
159    where
160        T: ?Sized + Serialize,
161    {
162        value.serialize(self)
163    }
164
165    fn serialize_newtype_variant<T>(
166        self,
167        _name: &'static str,
168        _variant_index: u32,
169        _variant: &'static str,
170        _value: &T,
171    ) -> Result<Self::Ok, Self::Error>
172    where
173        T: ?Sized + Serialize,
174    {
175        Err(self.unexpected())
176    }
177
178    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
179        Ok(SerializeExtSeq::new(self))
180    }
181
182    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
183        Err(self.unexpected())
184    }
185
186    fn serialize_tuple_struct(
187        self,
188        _name: &'static str,
189        _len: usize,
190    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
191        Err(self.unexpected())
192    }
193
194    fn serialize_tuple_variant(
195        self,
196        _name: &'static str,
197        _variant_index: u32,
198        _variant: &'static str,
199        _len: usize,
200    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
201        Err(self.unexpected())
202    }
203
204    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
205        Err(self.unexpected())
206    }
207
208    fn serialize_struct(
209        self,
210        _name: &'static str,
211        _len: usize,
212    ) -> Result<Self::SerializeStruct, Self::Error> {
213        Err(self.unexpected())
214    }
215
216    fn serialize_struct_variant(
217        self,
218        _name: &'static str,
219        _variant_index: u32,
220        _variant: &'static str,
221        _len: usize,
222    ) -> Result<Self::SerializeStructVariant, Self::Error> {
223        Err(self.unexpected())
224    }
225
226    fn collect_str<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
227    where
228        T: ?Sized + core::fmt::Display,
229    {
230        Err(self.unexpected())
231    }
232}
233
234pub struct SerializeExtSeq<'a, 'b, W> {
235    ser: &'a mut SerializeExt<'b, W>,
236}
237
238impl<'a, 'b, W> SerializeExtSeq<'a, 'b, W> {
239    pub(crate) fn new(ser: &'a mut SerializeExt<'b, W>) -> Self {
240        Self { ser }
241    }
242}
243
244impl<'a, 'b, W> ser::SerializeSeq for SerializeExtSeq<'a, 'b, W>
245where
246    'b: 'a,
247    W: IoWrite,
248{
249    type Ok = ();
250    type Error = Error<W::Error>;
251    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
252    where
253        T: ?Sized + Serialize,
254    {
255        value.serialize(self.ser.as_mut())
256    }
257    fn end(self) -> Result<Self::Ok, Self::Error> {
258        Ok(())
259    }
260}
261
262struct Bytes<'a>(pub &'a [u8]);
263impl ser::Serialize for Bytes<'_> {
264    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
265    where
266        S: Serializer,
267    {
268        serializer.serialize_bytes(self.0)
269    }
270}
271
272struct ExtInner<'a> {
273    kind: i8,
274    data: &'a [u8],
275}
276
277impl ser::Serialize for ExtInner<'_> {
278    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
279    where
280        S: Serializer,
281    {
282        let encoder = CoreExtensionRef::new(self.kind, self.data);
283        let format = encoder
284            .to_format::<core::convert::Infallible>()
285            .map_err(|_| ser::Error::custom("Invalid data length"))?;
286
287        let mut seq = serializer.serialize_seq(Some(4))?;
288
289        seq.serialize_element(&Bytes(&format.as_slice()))?;
290
291        match format {
292            messagepack_core::Format::FixExt1
293            | messagepack_core::Format::FixExt2
294            | messagepack_core::Format::FixExt4
295            | messagepack_core::Format::FixExt8
296            | messagepack_core::Format::FixExt16 => {}
297
298            messagepack_core::Format::Ext8 => {
299                let len = (self.data.len() as u8).to_be_bytes();
300                seq.serialize_element(&Bytes(&len))?;
301            }
302            messagepack_core::Format::Ext16 => {
303                let len = (self.data.len() as u16).to_be_bytes();
304                seq.serialize_element(&Bytes(&len))?;
305            }
306            messagepack_core::Format::Ext32 => {
307                let len = (self.data.len() as u32).to_be_bytes();
308                seq.serialize_element(&Bytes(&len))?;
309            }
310            _ => return Err(ser::Error::custom("unexpected format")),
311        };
312        seq.serialize_element(&Bytes(&self.kind.to_be_bytes()))?;
313        seq.serialize_element(&Bytes(self.data))?;
314
315        seq.end()
316    }
317}
318
319pub(crate) struct DeserializeExt<'a, R> {
320    data_len: usize,
321    reader: &'a mut R,
322}
323
324impl<'a, R> AsMut<Self> for DeserializeExt<'a, R> {
325    fn as_mut(&mut self) -> &mut Self {
326        self
327    }
328}
329
330impl<'de, 'a, R> DeserializeExt<'a, R>
331where
332    R: IoRead<'de>,
333{
334    pub(crate) fn new(
335        format: Format,
336        reader: &'a mut R,
337    ) -> Result<Self, crate::de::Error<R::Error>> {
338        use messagepack_core::decode::NbyteReader;
339        let data_len = match format {
340            Format::FixExt1 => 1,
341            Format::FixExt2 => 2,
342            Format::FixExt4 => 4,
343            Format::FixExt8 => 8,
344            Format::FixExt16 => 16,
345            Format::Ext8 => NbyteReader::<1>::read(reader)?,
346            Format::Ext16 => NbyteReader::<2>::read(reader)?,
347            Format::Ext32 => NbyteReader::<4>::read(reader)?,
348            _ => return Err(messagepack_core::decode::Error::UnexpectedFormat.into()),
349        };
350        Ok(DeserializeExt { data_len, reader })
351    }
352}
353
354impl<'de, 'a, R> serde::Deserializer<'de> for &mut DeserializeExt<'a, R>
355where
356    R: IoRead<'de>,
357{
358    type Error = crate::de::Error<R::Error>;
359
360    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
361    where
362        V: Visitor<'de>,
363    {
364        Err(serde::de::Error::custom(
365            "any when deserialize extension is not supported",
366        ))
367    }
368
369    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
370    where
371        V: Visitor<'de>,
372    {
373        let slice = self
374            .reader
375            .read_slice(1)
376            .map_err(messagepack_core::decode::Error::Io)?;
377        let buf: [u8; 1] = slice
378            .as_bytes()
379            .try_into()
380            .map_err(|_| messagepack_core::decode::Error::UnexpectedEof)?;
381
382        let val = i8::from_be_bytes(buf);
383        visitor.visit_i8(val)
384    }
385
386    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
387    where
388        V: Visitor<'de>,
389    {
390        let slice = self
391            .reader
392            .read_slice(self.data_len)
393            .map_err(messagepack_core::decode::Error::Io)?;
394        match slice {
395            messagepack_core::io::Reference::Borrowed(items) => visitor.visit_borrowed_bytes(items),
396            messagepack_core::io::Reference::Copied(items) => visitor.visit_bytes(items),
397        }
398    }
399
400    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
401    where
402        V: Visitor<'de>,
403    {
404        visitor.visit_seq(&mut self)
405    }
406
407    fn deserialize_newtype_struct<V>(
408        self,
409        _name: &'static str,
410        visitor: V,
411    ) -> Result<V::Value, Self::Error>
412    where
413        V: Visitor<'de>,
414    {
415        visitor.visit_newtype_struct(self)
416    }
417
418    serde::forward_to_deserialize_any! {
419        bool i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
420        byte_buf option unit unit_struct tuple
421        tuple_struct map struct enum identifier ignored_any
422    }
423}
424
425impl<'de, 'a, R> serde::de::SeqAccess<'de> for &mut DeserializeExt<'a, R>
426where
427    R: IoRead<'de>,
428{
429    type Error = crate::de::Error<R::Error>;
430    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
431    where
432        T: serde::de::DeserializeSeed<'de>,
433    {
434        seed.deserialize(self.as_mut()).map(Some)
435    }
436}
437
438/// De/Serialize [messagepack_core::extension::ExtensionRef]
439///
440/// ## Example
441///
442/// ```rust
443/// use serde::{Serialize,Deserialize};
444/// use messagepack_core::extension::ExtensionRef;
445///
446/// #[derive(Debug, Serialize, Deserialize, PartialEq)]
447/// #[serde(transparent)]
448/// struct WrapRef<'a>(
449///     #[serde(with = "messagepack_serde::value::ext_ref", borrow)] ExtensionRef<'a>,
450/// );
451///
452/// # fn main() {
453///
454/// let ext = WrapRef(
455///     ExtensionRef::new(10,&[0,1,2,3,4,5])
456/// );
457/// let mut buf = [0u8; 9];
458/// messagepack_serde::to_slice(&ext, &mut buf).unwrap();
459///
460/// let result = messagepack_serde::from_slice::<WrapRef<'_>>(&buf).unwrap();
461/// assert_eq!(ext,result);
462///
463/// # }
464/// ```
465pub mod ext_ref {
466    use super::*;
467    use serde::de;
468
469    /// Serialize [messagepack_core::extension::ExtensionRef]
470    pub fn serialize<S>(
471        ext: &messagepack_core::extension::ExtensionRef<'_>,
472        serializer: S,
473    ) -> Result<S::Ok, S::Error>
474    where
475        S: serde::Serializer,
476    {
477        serializer.serialize_newtype_struct(
478            EXTENSION_STRUCT_NAME,
479            &ExtInner {
480                kind: ext.r#type,
481                data: ext.data,
482            },
483        )
484    }
485
486    /// Deserialize [messagepack_core::extension::ExtensionRef]
487    pub fn deserialize<'de, D>(
488        deserializer: D,
489    ) -> Result<messagepack_core::extension::ExtensionRef<'de>, D::Error>
490    where
491        D: serde::Deserializer<'de>,
492    {
493        struct ExtensionVisitor;
494
495        impl<'de> Visitor<'de> for ExtensionVisitor {
496            type Value = messagepack_core::extension::ExtensionRef<'de>;
497            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
498                formatter.write_str("expect extension")
499            }
500
501            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
502            where
503                D: de::Deserializer<'de>,
504            {
505                deserializer.deserialize_seq(self)
506            }
507
508            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
509            where
510                A: serde::de::SeqAccess<'de>,
511            {
512                let kind = seq
513                    .next_element::<i8>()?
514                    .ok_or(de::Error::missing_field("extension type missing"))?;
515
516                let data = seq
517                    .next_element::<&[u8]>()?
518                    .ok_or(de::Error::missing_field("extension data missing"))?;
519
520                Ok(messagepack_core::extension::ExtensionRef::new(kind, data))
521            }
522        }
523        deserializer.deserialize_seq(ExtensionVisitor)
524    }
525}
526
527/// De/Serialize [messagepack_core::extension::FixedExtension]
528///
529/// ## Example
530///
531/// ```rust
532/// use serde::{Serialize,Deserialize};
533/// use messagepack_core::extension::FixedExtension;
534///
535/// #[derive(Debug, Serialize, Deserialize, PartialEq)]
536/// #[serde(transparent)]
537/// struct WrapRef(
538///     #[serde(with = "messagepack_serde::value::ext_fixed")] FixedExtension<16>,
539/// );
540///
541/// # fn main() {
542///
543/// let ext = WrapRef(
544///     FixedExtension::new(10,&[0,1,2,3,4,5]).unwrap()
545/// );
546/// let mut buf = [0u8; 9];
547/// messagepack_serde::to_slice(&ext, &mut buf).unwrap();
548///
549/// let result = messagepack_serde::from_slice::<WrapRef>(&buf).unwrap();
550/// assert_eq!(ext,result);
551///
552/// # }
553/// ```
554pub mod ext_fixed {
555    use super::*;
556    use serde::{Deserialize, de};
557
558    /// Serialize [messagepack_core::extension::FixedExtension]
559    pub fn serialize<const N: usize, S>(
560        ext: &messagepack_core::extension::FixedExtension<N>,
561        serializer: S,
562    ) -> Result<S::Ok, S::Error>
563    where
564        S: serde::Serializer,
565    {
566        super::ext_ref::serialize(&ext.as_ref(), serializer)
567    }
568
569    /// Deserialize [messagepack_core::extension::FixedExtension]
570    pub fn deserialize<'de, const N: usize, D>(
571        deserializer: D,
572    ) -> Result<messagepack_core::extension::FixedExtension<N>, D::Error>
573    where
574        D: serde::Deserializer<'de>,
575    {
576        struct Data<const N: usize> {
577            len: usize,
578            buf: [u8; N],
579        }
580        impl<'de, const N: usize> Deserialize<'de> for Data<N> {
581            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
582            where
583                D: de::Deserializer<'de>,
584            {
585                struct DataVisitor<const N: usize>;
586                impl<'de, const N: usize> Visitor<'de> for DataVisitor<N> {
587                    type Value = Data<N>;
588                    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
589                        formatter.write_str("expect extension")
590                    }
591
592                    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
593                    where
594                        E: de::Error,
595                    {
596                        let len = v.len();
597
598                        if len > N {
599                            return Err(de::Error::invalid_length(len, &self));
600                        }
601
602                        let mut buf = [0; N];
603                        buf[..len].copy_from_slice(v);
604                        Ok(Data { len, buf })
605                    }
606                }
607                deserializer.deserialize_bytes(DataVisitor)
608            }
609        }
610
611        struct ExtensionVisitor<const N: usize>;
612        impl<'de, const N: usize> Visitor<'de> for ExtensionVisitor<N> {
613            type Value = messagepack_core::extension::FixedExtension<N>;
614            fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
615                formatter.write_str("expect extension")
616            }
617
618            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
619            where
620                D: de::Deserializer<'de>,
621            {
622                deserializer.deserialize_seq(self)
623            }
624
625            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
626            where
627                A: de::SeqAccess<'de>,
628            {
629                let kind = seq
630                    .next_element::<i8>()?
631                    .ok_or(serde::de::Error::missing_field("extension type missing"))?;
632                let data = seq
633                    .next_element::<Data<N>>()?
634                    .ok_or(de::Error::missing_field("extension data missing"))?;
635
636                let ext = messagepack_core::extension::FixedExtension::new_fixed(
637                    kind, data.len, data.buf,
638                );
639                Ok(ext)
640            }
641        }
642
643        deserializer.deserialize_seq(ExtensionVisitor)
644    }
645}
646
647/// De/Serialize messagepack timestamp 32 extension.
648///
649/// This module allows serializing and deserializing
650/// `messagepack_core::timestamp::Timestamp32` as MessagePack
651/// timestamp extension (type `-1`, 4‑byte payload).
652///
653/// ## Example
654///
655/// ```rust
656/// use serde::{Serialize,Deserialize};
657/// use messagepack_core::timestamp::Timestamp32;
658///
659/// #[derive(Debug, Serialize, Deserialize, PartialEq)]
660/// struct Wrap(
661///     #[serde(with = "messagepack_serde::value::timestamp32")] Timestamp32,
662/// );
663///
664/// # fn main() {
665/// let v = Wrap(Timestamp32::new(123456));
666/// let mut buf = [0u8; 16];
667/// let n = messagepack_serde::to_slice(&v, &mut buf).unwrap();
668/// let back = messagepack_serde::from_slice::<Wrap>(&buf[..n]).unwrap();
669/// assert_eq!(v, back);
670/// # }
671/// ```
672pub mod timestamp32 {
673    /// Serialize `Timestamp32` as MessagePack extension.
674    pub fn serialize<S>(
675        ts: &messagepack_core::timestamp::Timestamp32,
676        serializer: S,
677    ) -> Result<S::Ok, S::Error>
678    where
679        S: serde::Serializer,
680    {
681        let ext: messagepack_core::extension::FixedExtension<4> = (*ts).into();
682        super::ext_fixed::serialize::<4, _>(&ext, serializer)
683    }
684
685    /// Deserialize `Timestamp32` from MessagePack extension.
686    pub fn deserialize<'de, D>(
687        deserializer: D,
688    ) -> Result<messagepack_core::timestamp::Timestamp32, D::Error>
689    where
690        D: serde::Deserializer<'de>,
691    {
692        let ext = super::ext_fixed::deserialize::<4, _>(deserializer)?;
693        ext.try_into()
694            .map_err(|_| serde::de::Error::custom("invalid timestamp32"))
695    }
696}
697
698/// De/Serialize messagepack timestamp 64 extension.
699///
700/// This module allows serializing and deserializing
701/// `messagepack_core::timestamp::Timestamp64` as MessagePack
702/// timestamp extension (type `-1`, 8‑byte payload).
703///
704/// ## Example
705///
706/// ```rust
707/// use serde::{Serialize,Deserialize};
708/// use messagepack_core::timestamp::Timestamp64;
709///
710/// #[derive(Debug, Serialize, Deserialize, PartialEq)]
711/// struct Wrap(
712///     #[serde(with = "messagepack_serde::value::timestamp64")] Timestamp64,
713/// );
714///
715/// # fn main() {
716/// let v = Wrap(Timestamp64::new(123456, 789).unwrap());
717/// let mut buf = [0u8; 32];
718/// let n = messagepack_serde::to_slice(&v, &mut buf).unwrap();
719/// let back = messagepack_serde::from_slice::<Wrap>(&buf[..n]).unwrap();
720/// assert_eq!(v, back);
721/// # }
722/// ```
723pub mod timestamp64 {
724    /// Serialize `Timestamp64` as MessagePack extension.
725    pub fn serialize<S>(
726        ts: &messagepack_core::timestamp::Timestamp64,
727        serializer: S,
728    ) -> Result<S::Ok, S::Error>
729    where
730        S: serde::Serializer,
731    {
732        let ext: messagepack_core::extension::FixedExtension<8> = (*ts).into();
733        super::ext_fixed::serialize::<8, _>(&ext, serializer)
734    }
735
736    /// Deserialize `Timestamp64` from MessagePack extension.
737    pub fn deserialize<'de, D>(
738        deserializer: D,
739    ) -> Result<messagepack_core::timestamp::Timestamp64, D::Error>
740    where
741        D: serde::Deserializer<'de>,
742    {
743        let ext = super::ext_fixed::deserialize::<8, _>(deserializer)?;
744        ext.try_into()
745            .map_err(|_| serde::de::Error::custom("invalid timestamp64"))
746    }
747}
748
749/// De/Serialize messagepack timestamp 96 extension.
750///
751/// This module allows serializing and deserializing
752/// `messagepack_core::timestamp::Timestamp96` as MessagePack
753/// timestamp extension (type `-1`, 12‑byte payload).
754///
755/// ## Example
756///
757/// ```rust
758/// use serde::{Serialize,Deserialize};
759/// use messagepack_core::timestamp::Timestamp96;
760///
761/// #[derive(Debug, Serialize, Deserialize, PartialEq)]
762/// struct Wrap(
763///     #[serde(with = "messagepack_serde::value::timestamp96")] Timestamp96,
764/// );
765///
766/// # fn main() {
767/// let v = Wrap(Timestamp96::new(123456, 789));
768/// let mut buf = [0u8; 32];
769/// let n = messagepack_serde::to_slice(&v, &mut buf).unwrap();
770/// let back = messagepack_serde::from_slice::<Wrap>(&buf[..n]).unwrap();
771/// assert_eq!(v, back);
772/// # }
773/// ```
774pub mod timestamp96 {
775    /// Serialize `Timestamp96` as MessagePack extension.
776    pub fn serialize<S>(
777        ts: &messagepack_core::timestamp::Timestamp96,
778        serializer: S,
779    ) -> Result<S::Ok, S::Error>
780    where
781        S: serde::Serializer,
782    {
783        let ext: messagepack_core::extension::FixedExtension<12> = (*ts).into();
784        super::ext_fixed::serialize::<12, _>(&ext, serializer)
785    }
786
787    /// Deserialize `Timestamp96` from MessagePack extension.
788    pub fn deserialize<'de, D>(
789        deserializer: D,
790    ) -> Result<messagepack_core::timestamp::Timestamp96, D::Error>
791    where
792        D: serde::Deserializer<'de>,
793    {
794        let ext = super::ext_fixed::deserialize::<12, _>(deserializer)?;
795        ext.try_into()
796            .map_err(|_| serde::de::Error::custom("invalid timestamp96"))
797    }
798}
799
800#[cfg(test)]
801mod tests {
802    use super::*;
803
804    use messagepack_core::extension::{ExtensionRef, FixedExtension};
805    use messagepack_core::timestamp::{Timestamp32, Timestamp64, Timestamp96};
806    use rstest::rstest;
807    use serde::{Deserialize, Serialize};
808
809    #[derive(Debug, Serialize, Deserialize)]
810    struct WrapRef<'a>(
811        #[serde(with = "ext_ref", borrow)] messagepack_core::extension::ExtensionRef<'a>,
812    );
813
814    #[rstest]
815    fn encode_ext_ref() {
816        let mut buf = [0_u8; 3];
817
818        let kind: i8 = 123;
819
820        let ext = WrapRef(ExtensionRef::new(kind, &[0x12]));
821        let length = crate::to_slice(&ext, &mut buf).unwrap();
822
823        assert_eq!(length, 3);
824        assert_eq!(buf, [0xd4, kind.to_be_bytes()[0], 0x12]);
825    }
826
827    #[rstest]
828    fn decode_ext_ref() {
829        let buf = [0xd6, 0xff, 0x00, 0x00, 0x00, 0x00]; // timestamp ext type
830
831        let ext = crate::from_slice::<WrapRef<'_>>(&buf).unwrap().0;
832        assert_eq!(ext.r#type, -1);
833        let seconds = u32::from_be_bytes(ext.data.try_into().unwrap());
834        assert_eq!(seconds, 0);
835    }
836
837    #[derive(Debug, Serialize, Deserialize)]
838    struct WrapFixed<const N: usize>(
839        #[serde(with = "ext_fixed")] messagepack_core::extension::FixedExtension<N>,
840    );
841
842    #[rstest]
843    fn encode_ext_fixed() {
844        let mut buf = [0u8; 3];
845        let kind: i8 = 123;
846
847        let ext = WrapFixed(FixedExtension::new_fixed(kind, 1, [0x12]));
848        let length = crate::to_slice(&ext, &mut buf).unwrap();
849
850        assert_eq!(length, 3);
851        assert_eq!(buf, [0xd4, kind.to_be_bytes()[0], 0x12]);
852    }
853
854    const TIMESTAMP32: &[u8] = &[0xd6, 0xff, 0x00, 0x00, 0x00, 0x00];
855
856    #[rstest]
857    fn decode_ext_fixed_bigger_will_success() {
858        let ext = crate::from_slice::<WrapFixed<6>>(TIMESTAMP32).unwrap().0;
859        assert_eq!(ext.r#type, -1);
860        assert_eq!(ext.as_slice(), &TIMESTAMP32[2..])
861    }
862
863    #[rstest]
864    #[should_panic]
865    fn decode_ext_fixed_smaller_will_failed() {
866        let _ = crate::from_slice::<WrapFixed<3>>(TIMESTAMP32).unwrap();
867    }
868
869    #[derive(Debug, Serialize, Deserialize, PartialEq)]
870    struct WrapTs32(#[serde(with = "timestamp32")] Timestamp32);
871
872    #[rstest]
873    fn encode_timestamp32() {
874        let ts = WrapTs32(Timestamp32::new(123456));
875        let mut buf = [0u8; 16];
876        let n = crate::to_slice(&ts, &mut buf).unwrap();
877
878        let mut expected = vec![0xd6, (-1i8 as u8)];
879        expected.extend_from_slice(&123456u32.to_be_bytes());
880        assert_eq!(&buf[..n], expected.as_slice());
881    }
882
883    #[rstest]
884    fn decode_timestamp32() {
885        let mut buf = vec![0xd6, (-1i8 as u8)];
886        buf.extend_from_slice(&0u32.to_be_bytes());
887        let v = crate::from_slice::<WrapTs32>(&buf).unwrap();
888        assert_eq!(v.0.seconds(), 0);
889    }
890
891    #[derive(Debug, Serialize, Deserialize, PartialEq)]
892    struct WrapTs64(#[serde(with = "timestamp64")] Timestamp64);
893
894    #[rstest]
895    fn encode_timestamp64() {
896        let ts = WrapTs64(Timestamp64::new(123456, 789).unwrap());
897        let mut buf = [0u8; 32];
898        let n = crate::to_slice(&ts, &mut buf).unwrap();
899
900        let mut expected = vec![0xd7, (-1i8 as u8)];
901        let data = ((789u64 << 34) | 123456).to_be_bytes();
902        expected.extend_from_slice(&data);
903        assert_eq!(&buf[..n], expected.as_slice());
904    }
905
906    #[rstest]
907    fn decode_timestamp64() {
908        let mut buf = vec![0xd7, (-1i8 as u8)];
909        let data = ((789u64 << 34) | 123456).to_be_bytes();
910        buf.extend_from_slice(&data);
911        let v = crate::from_slice::<WrapTs64>(&buf).unwrap();
912        assert_eq!(v.0.seconds(), 123456);
913        assert_eq!(v.0.nanos(), 789);
914    }
915
916    #[derive(Debug, Serialize, Deserialize, PartialEq)]
917    struct WrapTs96(#[serde(with = "timestamp96")] Timestamp96);
918
919    #[rstest]
920    fn encode_timestamp96() {
921        let ts = WrapTs96(Timestamp96::new(123456, 789));
922        let mut buf = [0u8; 32];
923        let n = crate::to_slice(&ts, &mut buf).unwrap();
924
925        let mut expected = vec![0xc7, 12, (-1i8 as u8)];
926        expected.extend_from_slice(&789u32.to_be_bytes());
927        expected.extend_from_slice(&123456u64.to_be_bytes());
928        assert_eq!(&buf[..n], expected.as_slice());
929    }
930
931    #[rstest]
932    fn decode_timestamp96() {
933        let mut buf = vec![0xc7, 12, (-1i8 as u8)];
934        buf.extend_from_slice(&789u32.to_be_bytes());
935        buf.extend_from_slice(&123456u64.to_be_bytes());
936        let v = crate::from_slice::<WrapTs96>(&buf).unwrap();
937        assert_eq!(v.0.seconds(), 123456);
938        assert_eq!(v.0.nanos(), 789);
939    }
940}
messagepack_serde/value/extension.rs

messagepack_serde/value/
extension.rs
