zenoh_ext/
serialization.rs

1//
2// Copyright (c) 2024 ZettaScale Technology
3//
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
7// which is available at https://www.apache.org/licenses/LICENSE-2.0.
8//
9// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
10//
11// Contributors:
12//   ZettaScale Zenoh Team, <zenoh@zettascale.tech>
13//
14use std::{
15    borrow::Cow,
16    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
17    fmt,
18    hash::Hash,
19    io::{Read, Write},
20    marker::PhantomData,
21    mem::MaybeUninit,
22};
23
24use zenoh::bytes::{ZBytes, ZBytesReader, ZBytesWriter};
25
26/// Error occurring in deserialization.
27#[derive(Debug)]
28pub struct ZDeserializeError;
29impl fmt::Display for ZDeserializeError {
30    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
31        write!(f, "deserialization error")
32    }
33}
34impl std::error::Error for ZDeserializeError {}
35
36fn default_serialize_n<T: Serialize>(slice: &[T], serializer: &mut ZSerializer) {
37    for t in slice {
38        t.serialize(serializer)
39    }
40}
41
42/// Serialization implementation.
43///
44/// See [Zenoh serialization format RFC][1].
45///
46/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
47pub trait Serialize {
48    /// Serialize the given object into a [`ZSerializer`].
49    ///
50    /// User may prefer to use [`ZSerializer::serialize`] instead of this function.
51    fn serialize(&self, serializer: &mut ZSerializer);
52    #[doc(hidden)]
53    fn serialize_n(slice: &[Self], serializer: &mut ZSerializer)
54    where
55        Self: Sized,
56    {
57        default_serialize_n(slice, serializer);
58    }
59}
60impl<T: Serialize + ?Sized> Serialize for &T {
61    fn serialize(&self, serializer: &mut ZSerializer) {
62        T::serialize(*self, serializer)
63    }
64}
65
66fn default_deserialize_n<T: Deserialize>(
67    in_place: &mut [T],
68    deserializer: &mut ZDeserializer,
69) -> Result<(), ZDeserializeError> {
70    for t in in_place {
71        *t = T::deserialize(deserializer)?;
72    }
73    Ok(())
74}
75
76fn default_deserialize_n_uninit<'a, T: Deserialize>(
77    in_place: &'a mut [MaybeUninit<T>],
78    deserializer: &mut ZDeserializer,
79) -> Result<&'a mut [T], ZDeserializeError> {
80    for t in in_place.iter_mut() {
81        t.write(T::deserialize(deserializer)?);
82    }
83    // SAFETY: all members of the slices have been initialized
84    Ok(unsafe { &mut *(in_place as *mut [MaybeUninit<T>] as *mut [T]) })
85}
86
87/// Deserialization implementation.
88///
89/// See [Zenoh serialization format RFC][1].
90///
91/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
92pub trait Deserialize: Sized {
93    /// Deserialize the given type from a [`ZDeserializer`].
94    ///
95    /// User may prefer to use [`ZDeserializer::deserialize`] instead of this function.
96    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError>;
97    #[doc(hidden)]
98    fn deserialize_n(
99        in_place: &mut [Self],
100        deserializer: &mut ZDeserializer,
101    ) -> Result<(), ZDeserializeError> {
102        default_deserialize_n(in_place, deserializer)
103    }
104    #[doc(hidden)]
105    fn deserialize_n_uninit<'a>(
106        in_place: &'a mut [MaybeUninit<Self>],
107        deserializer: &mut ZDeserializer,
108    ) -> Result<&'a mut [Self], ZDeserializeError> {
109        default_deserialize_n_uninit(in_place, deserializer)
110    }
111}
112
113/// Serialize an object according to the [Zenoh serialization format][1].
114///
115/// Serialization doesn't take the ownership of the data.
116///
117/// # Examples
118///
119/// ```rust
120/// use zenoh_ext::*;
121/// let zbytes = z_serialize(&(42i32, vec![1u8, 2, 3]));
122/// assert_eq!(z_deserialize::<(i32, Vec<u8>)>(&zbytes).unwrap(), (42i32, vec![1u8, 2, 3]));
123/// ```
124///
125/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
126pub fn z_serialize<T: Serialize + ?Sized>(t: &T) -> ZBytes {
127    let mut serializer = ZSerializer::new();
128    serializer.serialize(t);
129    serializer.finish()
130}
131
132/// Deserialize an object according to the [Zenoh serialization format][1].
133///
134/// # Examples
135///
136/// ```rust
137/// use zenoh_ext::*;
138/// let zbytes = z_serialize(&(42i32, vec![1u8, 2, 3]));
139/// assert_eq!(z_deserialize::<(i32, Vec<u8>)>(&zbytes).unwrap(), (42i32, vec![1u8, 2, 3]));
140/// ```
141///
142/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
143pub fn z_deserialize<T: Deserialize>(zbytes: &ZBytes) -> Result<T, ZDeserializeError> {
144    let mut deserializer = ZDeserializer::new(zbytes);
145    let t = T::deserialize(&mut deserializer)?;
146    if !deserializer.done() {
147        return Err(ZDeserializeError);
148    }
149    Ok(t)
150}
151
152/// Serializer implementing the [Zenoh serialization format][1].
153///
154/// Serializing objects one after the other is equivalent to serialize a tuple of these objects.
155///
156/// # Examples
157///
158/// ```rust
159/// use zenoh_ext::*;
160/// let mut serializer = ZSerializer::new();
161/// serializer.serialize(42i32);
162/// serializer.serialize(vec![1u8, 2, 3]);
163/// let zbytes = serializer.finish();
164/// assert_eq!(z_deserialize::<(i32, Vec<u8>)>(&zbytes).unwrap(), (42i32, vec![1u8, 2, 3]));
165/// ```
166///
167/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
168#[derive(Debug)]
169pub struct ZSerializer(ZBytesWriter);
170
171impl ZSerializer {
172    /// Instantiate a [`ZSerializer`].
173    pub fn new() -> Self {
174        Self(ZBytes::writer())
175    }
176
177    /// Serialize the given object into a [`ZSerializer`].
178    ///
179    /// Serialization doesn't take the ownership of the data.
180    pub fn serialize<T: Serialize>(&mut self, t: T) {
181        t.serialize(self)
182    }
183
184    /// Serialize the given iterator into a [`ZSerializer`].
185    ///
186    /// Sequence serialized with this method may be deserialized with [`ZDeserializer::deserialize_iter`].
187    /// See [Zenoh serialization format RFC][1].
188    ///
189    /// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md#sequences
190    pub fn serialize_iter<T: Serialize, I: IntoIterator<Item = T>>(&mut self, iter: I)
191    where
192        I::IntoIter: ExactSizeIterator,
193    {
194        let iter = iter.into_iter();
195        self.serialize(VarInt(iter.len()));
196        for t in iter {
197            t.serialize(self);
198        }
199    }
200
201    /// Finish serialization by returning a [`ZBytes`].
202    pub fn finish(self) -> ZBytes {
203        self.0.finish()
204    }
205}
206
207impl Default for ZSerializer {
208    fn default() -> Self {
209        Self::new()
210    }
211}
212
213impl From<ZSerializer> for ZBytes {
214    fn from(value: ZSerializer) -> Self {
215        value.finish()
216    }
217}
218
219/// Deserializer implementing the [Zenoh serialization format][1].
220///
221/// Deserializing objects one after the other is equivalent to serialize a tuple of these objects.
222///
223/// # Examples
224///
225/// ```rust
226/// use zenoh_ext::*;
227/// let zbytes = z_serialize(&(42i32, vec![1u8, 2, 3]));
228/// let mut deserializer = ZDeserializer::new(&zbytes);
229/// assert_eq!(deserializer.deserialize::<i32>().unwrap(), 42i32);
230/// assert_eq!(deserializer.deserialize::<Vec<u8>>().unwrap(), vec![1u8, 2, 3]);
231/// assert!(deserializer.done())
232/// ```
233///
234/// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md
235#[derive(Debug)]
236pub struct ZDeserializer<'a>(ZBytesReader<'a>);
237
238impl<'a> ZDeserializer<'a> {
239    /// Instantiate a [`ZDeserializer`] from a [`ZBytes`].
240    pub fn new(zbytes: &'a ZBytes) -> Self {
241        Self(zbytes.reader())
242    }
243
244    /// Return true if there is no data left to deserialize.
245    pub fn done(&self) -> bool {
246        self.0.is_empty()
247    }
248
249    /// Deserialize the given type from a [`ZDeserializer`].
250    pub fn deserialize<T: Deserialize>(&mut self) -> Result<T, ZDeserializeError> {
251        T::deserialize(self)
252    }
253
254    /// Deserialize an iterator into a [`ZDeserializer`].
255    ///
256    /// Sequence deserialized with this method may have been serialized with [`ZSerializer::serialize_iter`].
257    /// See [Zenoh serialization format RFC][1].
258    ///
259    /// [1]: https://github.com/eclipse-zenoh/roadmap/blob/main/rfcs/ALL/Serialization.md#sequences
260    pub fn deserialize_iter<'b, T: Deserialize>(
261        &'b mut self,
262    ) -> Result<ZReadIter<'a, 'b, T>, ZDeserializeError> {
263        let len = <VarInt<usize>>::deserialize(self)?.0;
264        Ok(ZReadIter {
265            deserializer: self,
266            len,
267            _phantom: PhantomData,
268        })
269    }
270}
271
272/// Iterator returned by [`ZDeserializer::deserialize_iter`].
273pub struct ZReadIter<'a, 'b, T: Deserialize> {
274    deserializer: &'b mut ZDeserializer<'a>,
275    len: usize,
276    _phantom: PhantomData<T>,
277}
278
279impl<T: Deserialize> Iterator for ZReadIter<'_, '_, T> {
280    type Item = Result<T, ZDeserializeError>;
281    fn next(&mut self) -> Option<Self::Item> {
282        if self.len == 0 {
283            return None;
284        }
285        self.len -= 1;
286        Some(T::deserialize(self.deserializer))
287    }
288
289    fn size_hint(&self) -> (usize, Option<usize>) {
290        (self.len, Some(self.len))
291    }
292}
293
294impl<T: Deserialize> ExactSizeIterator for ZReadIter<'_, '_, T> {}
295
296impl<T: Deserialize> Drop for ZReadIter<'_, '_, T> {
297    fn drop(&mut self) {
298        self.by_ref().for_each(drop);
299    }
300}
301
302impl Serialize for ZBytes {
303    fn serialize(&self, serializer: &mut ZSerializer) {
304        serializer.serialize(VarInt(self.len()));
305        serializer.0.append(self.clone());
306    }
307}
308
309macro_rules! impl_num {
310    ($($ty:ty),* $(,)?) => {$(
311        impl Serialize for $ty {
312            fn serialize(&self, serializer: &mut ZSerializer) {
313                serializer.0.write_all(&(*self).to_le_bytes()).unwrap();
314            }
315            fn serialize_n(slice: &[Self], serializer: &mut ZSerializer) where Self: Sized {
316                if cfg!(target_endian = "little") || std::mem::size_of::<Self>() == 1 {
317                    // SAFETY: transmuting numeric types to their little endian bytes is safe
318                    serializer.0.write_all(unsafe { slice.align_to().1 }).unwrap();
319                } else {
320                    default_serialize_n(slice, serializer)
321                }
322            }
323        }
324        impl Deserialize for $ty {
325            fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
326                let mut buf = [0; { std::mem::size_of::<Self>() }];
327                deserializer.0.read_exact(&mut buf).or(Err(ZDeserializeError))?;
328                Ok(<$ty>::from_le_bytes(buf))
329            }
330            fn deserialize_n(in_place: &mut [Self], deserializer: &mut ZDeserializer) -> Result<(), ZDeserializeError> {
331                let size = std::mem::size_of::<Self>();
332                if cfg!(target_endian = "little") || size == 1 {
333                    // SAFETY: transmuting numeric types to their little endian bytes is safe
334                    let buf = unsafe {in_place.align_to_mut().1};
335                    deserializer.0.read_exact(buf).or(Err(ZDeserializeError))?;
336                    Ok(())
337                } else {
338                    default_deserialize_n(in_place, deserializer)
339                }
340            }
341            fn deserialize_n_uninit<'a>(in_place: &'a mut [MaybeUninit<Self>], deserializer: &mut ZDeserializer) -> Result<&'a mut [Self], ZDeserializeError> {
342                if cfg!(target_endian = "little") ||  std::mem::size_of::<Self>() == 1 {
343                    // need to initialize the slice because of std::io::Read interface
344                    in_place.fill(MaybeUninit::new(Self::default()));
345                    // SAFETY: all members of the slices have been initialized
346                    let initialized = unsafe { &mut *(in_place as *mut [MaybeUninit<Self>] as *mut [Self]) };
347                    Self::deserialize_n(initialized, deserializer)?;
348                    Ok(initialized)
349                } else {
350                    default_deserialize_n_uninit(in_place, deserializer)
351                }
352            }
353        }
354    )*};
355}
356impl_num!(i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, f64);
357
358impl Serialize for bool {
359    fn serialize(&self, serializer: &mut ZSerializer) {
360        (*self as u8).serialize(serializer);
361    }
362}
363impl Deserialize for bool {
364    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
365        match u8::deserialize(deserializer)? {
366            0 => Ok(false),
367            1 => Ok(true),
368            _ => Err(ZDeserializeError),
369        }
370    }
371}
372
373fn serialize_slice<T: Serialize>(slice: &[T], serializer: &mut ZSerializer) {
374    serializer.serialize(VarInt(slice.len()));
375    T::serialize_n(slice, serializer);
376}
377
378fn deserialize_slice<T: Deserialize>(
379    deserializer: &mut ZDeserializer,
380) -> Result<Box<[T]>, ZDeserializeError> {
381    let len = <VarInt<usize>>::deserialize(deserializer)?.0;
382    let mut vec = Vec::with_capacity(len);
383    let slice = T::deserialize_n_uninit(&mut vec.spare_capacity_mut()[..len], deserializer)?;
384    let (slice_ptr, slice_len) = (slice.as_ptr(), slice.len());
385    assert_eq!((slice_ptr, slice_len), (vec.as_ptr(), len));
386    // SAFETY: assertion checks the returned slice is vector's one, and it's returned initialized
387    unsafe { vec.set_len(len) };
388    Ok(vec.into_boxed_slice())
389}
390
391impl<T: Serialize> Serialize for [T] {
392    fn serialize(&self, serializer: &mut ZSerializer) {
393        serialize_slice(self, serializer);
394    }
395}
396impl<T: Serialize, const N: usize> Serialize for [T; N] {
397    fn serialize(&self, serializer: &mut ZSerializer) {
398        serialize_slice(self.as_slice(), serializer);
399    }
400}
401impl<'a, T: Serialize + 'a> Serialize for Cow<'a, [T]>
402where
403    [T]: ToOwned,
404{
405    fn serialize(&self, serializer: &mut ZSerializer) {
406        serialize_slice(self, serializer);
407    }
408}
409impl<T: Serialize> Serialize for Box<[T]> {
410    fn serialize(&self, serializer: &mut ZSerializer) {
411        serialize_slice(self, serializer);
412    }
413}
414impl<T: Deserialize> Deserialize for Box<[T]> {
415    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
416        deserialize_slice(deserializer)
417    }
418}
419impl<T: Serialize> Serialize for Vec<T> {
420    fn serialize(&self, serializer: &mut ZSerializer) {
421        serialize_slice(self, serializer)
422    }
423}
424impl<T: Deserialize, const N: usize> Deserialize for [T; N] {
425    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
426        if <VarInt<usize>>::deserialize(deserializer)?.0 != N {
427            return Err(ZDeserializeError);
428        }
429        let mut array = std::array::from_fn(|_| MaybeUninit::uninit());
430        let slice = T::deserialize_n_uninit(&mut array, deserializer)?;
431        let (slice_ptr, slice_len) = (slice.as_ptr(), slice.len());
432        assert_eq!((slice_ptr, slice_len), (array.as_ptr().cast::<T>(), N));
433        // SAFETY: assertion checks the returned slice is array's one, and it's returned initialized
434        Ok(array.map(|t| unsafe { t.assume_init() }))
435    }
436}
437impl<T: Deserialize> Deserialize for Vec<T> {
438    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
439        Ok(deserialize_slice(deserializer)?.into_vec())
440    }
441}
442impl<T: Serialize + Eq + Hash> Serialize for HashSet<T> {
443    fn serialize(&self, serializer: &mut ZSerializer) {
444        serializer.serialize_iter(self);
445    }
446}
447impl<T: Deserialize + Eq + Hash> Deserialize for HashSet<T> {
448    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
449        deserializer.deserialize_iter()?.collect()
450    }
451}
452impl<T: Serialize + Ord> Serialize for BTreeSet<T> {
453    fn serialize(&self, serializer: &mut ZSerializer) {
454        serializer.serialize_iter(self);
455    }
456}
457impl<T: Deserialize + Ord> Deserialize for BTreeSet<T> {
458    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
459        deserializer.deserialize_iter()?.collect()
460    }
461}
462impl<K: Serialize + Eq + Hash, V: Serialize> Serialize for HashMap<K, V> {
463    fn serialize(&self, serializer: &mut ZSerializer) {
464        serializer.serialize_iter(self);
465    }
466}
467impl<K: Deserialize + Eq + Hash, V: Deserialize> Deserialize for HashMap<K, V> {
468    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
469        deserializer.deserialize_iter()?.collect()
470    }
471}
472impl<K: Serialize + Ord, V: Serialize> Serialize for BTreeMap<K, V> {
473    fn serialize(&self, serializer: &mut ZSerializer) {
474        serializer.serialize_iter(self);
475    }
476}
477impl<K: Deserialize + Ord, V: Deserialize> Deserialize for BTreeMap<K, V> {
478    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
479        deserializer.deserialize_iter()?.collect()
480    }
481}
482impl Serialize for str {
483    fn serialize(&self, serializer: &mut ZSerializer) {
484        self.as_bytes().serialize(serializer);
485    }
486}
487impl Serialize for Cow<'_, str> {
488    fn serialize(&self, serializer: &mut ZSerializer) {
489        self.as_bytes().serialize(serializer);
490    }
491}
492impl Serialize for String {
493    fn serialize(&self, serializer: &mut ZSerializer) {
494        self.as_bytes().serialize(serializer);
495    }
496}
497impl Deserialize for String {
498    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
499        String::from_utf8(Deserialize::deserialize(deserializer)?).or(Err(ZDeserializeError))
500    }
501}
502
503macro_rules! impl_tuple {
504    ($($ty:ident/$i:tt),* $(,)?) => {
505        impl_tuple!(@;$($ty/$i),*);
506    };
507    (@$($ty:ident/$i:tt),*; $next:ident/$next_i:tt $(, $remain:ident/$remain_i:tt)*) => {
508        impl_tuple!(@@$($ty/$i),*);
509        impl_tuple!(@$($ty/$i,)* $next/$next_i; $($remain/$remain_i),*);
510    };
511    (@$($ty:ident/$i:tt),*;) => {
512        impl_tuple!(@@$($ty/$i),*);
513    };
514    (@@$($ty:ident/$i:tt),* $(,)?) => {
515        #[allow(unused)]
516        impl<$($ty: Serialize),*> Serialize for ($($ty,)*) {
517            fn serialize(&self, serializer: &mut ZSerializer) {
518                $(self.$i.serialize(serializer);)*
519            }
520        }
521        #[allow(unused)]
522        impl<$($ty: Deserialize),*> Deserialize for ($($ty,)*) {
523            fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
524                Ok(($($ty::deserialize(deserializer)?,)*))
525            }
526        }
527    };
528}
529impl_tuple!(
530    T0 / 0,
531    T1 / 1,
532    T2 / 2,
533    T3 / 3,
534    T4 / 4,
535    T5 / 5,
536    T6 / 6,
537    T7 / 7,
538    T8 / 8,
539    T9 / 9,
540    T10 / 10,
541    T11 / 11,
542    T12 / 12,
543    T13 / 13,
544    T14 / 14,
545    T15 / 15,
546);
547
548#[repr(transparent)]
549#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
550pub struct VarInt<T>(pub T);
551impl Serialize for VarInt<usize> {
552    fn serialize(&self, serializer: &mut ZSerializer) {
553        leb128::write::unsigned(&mut serializer.0, self.0 as u64).unwrap();
554    }
555}
556impl Deserialize for VarInt<usize> {
557    fn deserialize(deserializer: &mut ZDeserializer) -> Result<Self, ZDeserializeError> {
558        let n = leb128::read::unsigned(&mut deserializer.0).or(Err(ZDeserializeError))?;
559        Ok(VarInt(<usize>::try_from(n).or(Err(ZDeserializeError))?))
560    }
561}
562
563#[cfg(test)]
564mod tests {
565    use std::ops::Range;
566
567    use rand::{thread_rng, Rng};
568
569    use super::*;
570
571    macro_rules! serialize_deserialize {
572        ($ty:ty, $expr:expr) => {
573            let expr: &$ty = &$expr;
574            let payload = z_serialize(expr);
575            let output = z_deserialize::<$ty>(&payload).unwrap();
576            assert_eq!(*expr, output);
577        };
578    }
579
580    const RANDOM_TESTS: Range<usize> = 0..1_000;
581
582    #[test]
583    fn numeric_serialization() {
584        macro_rules! test_int {
585            ($($ty:ty),* $(,)?) => {$(
586                serialize_deserialize!($ty, <$ty>::MIN);
587                serialize_deserialize!($ty, <$ty>::MAX);
588                let mut rng = thread_rng();
589                for _ in RANDOM_TESTS {
590                    serialize_deserialize!($ty, rng.gen::<$ty>());
591                }
592            )*};
593        }
594        test_int!(i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, f32, f64);
595    }
596
597    #[test]
598    fn varint_serialization() {
599        serialize_deserialize!(VarInt<usize>, VarInt(<usize>::MIN));
600        serialize_deserialize!(VarInt<usize>, VarInt(<usize>::MAX));
601        let mut rng = thread_rng();
602        for _ in RANDOM_TESTS {
603            serialize_deserialize!(VarInt<usize>, VarInt(rng.gen::<usize>()));
604        }
605    }
606
607    #[test]
608    fn primitive_slice_serialization() {
609        let vec = vec![42.0f64, 0.15];
610        serialize_deserialize!(Vec<f64>, vec);
611        let payload = z_serialize(vec.as_slice());
612        assert_eq!(vec, z_deserialize::<Vec<f64>>(&payload).unwrap())
613    }
614
615    #[test]
616    fn slice_serialization() {
617        let vec = vec!["abc".to_string(), "def".to_string()];
618        serialize_deserialize!(Vec<String>, vec);
619        let payload = z_serialize(vec.as_slice());
620        assert_eq!(vec, z_deserialize::<Vec<String>>(&payload).unwrap())
621    }
622
623    #[test]
624    fn string_serialization() {
625        let s = "serialization".to_string();
626        serialize_deserialize!(String, s);
627        let payload = z_serialize(s.as_str());
628        assert_eq!(s, z_deserialize::<String>(&payload).unwrap())
629    }
630
631    #[test]
632    fn tuple_serialization() {
633        serialize_deserialize!(
634            (VarInt<usize>, f32, String),
635            (VarInt(42), 42.0f32, "42".to_string())
636        );
637    }
638
639    #[test]
640    fn hashmap_serialization() {
641        let mut map = HashMap::new();
642        map.insert("hello".to_string(), "world".to_string());
643        serialize_deserialize!(HashMap<String, String>, map);
644    }
645
646    macro_rules! check_binary_format {
647        ($expr:expr, $out:expr) => {
648            let payload = z_serialize(&$expr);
649            assert_eq!(payload.to_bytes(), $out);
650        };
651    }
652
653    #[test]
654    fn binary_format() {
655        let i1: i32 = 1234566;
656        check_binary_format!(i1, vec![134, 214, 18, 0]);
657        let i2: i32 = -49245;
658        check_binary_format!(i2, vec![163, 63, 255, 255]);
659        let s: &str = "test";
660        check_binary_format!(s, vec![4, 116, 101, 115, 116]);
661        let t: (u16, f32, &str) = (500, 1234.0, "test");
662        check_binary_format!(t, vec![244, 1, 0, 64, 154, 68, 4, 116, 101, 115, 116]);
663        let v: Vec<i64> = vec![-100, 500, 100000, -20000000];
664        check_binary_format!(
665            v,
666            vec![
667                4, 156, 255, 255, 255, 255, 255, 255, 255, 244, 1, 0, 0, 0, 0, 0, 0, 160, 134, 1,
668                0, 0, 0, 0, 0, 0, 211, 206, 254, 255, 255, 255, 255
669            ]
670        );
671        let vp: Vec<(&str, i16)> = vec![("s1", 10), ("s2", -10000)];
672        check_binary_format!(vp, vec![2, 2, 115, 49, 10, 0, 2, 115, 50, 240, 216]);
673    }
674}
zenoh_ext/serialization.rs

zenoh_ext/
serialization.rs
