ntex_bytes/
serde.rs

1use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
2use std::{cmp, fmt};
3
4use super::{Bytes, BytesMut};
5
6macro_rules! serde_impl {
7    ($ty:ident, $visitor_ty:ident, $from_slice:ident) => {
8        impl Serialize for $ty {
9            #[inline]
10            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
11            where
12                S: Serializer,
13            {
14                serializer.serialize_bytes(&self)
15            }
16        }
17
18        struct $visitor_ty;
19
20        impl<'de> de::Visitor<'de> for $visitor_ty {
21            type Value = $ty;
22
23            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
24                formatter.write_str("byte array")
25            }
26
27            #[inline]
28            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
29            where
30                V: de::SeqAccess<'de>,
31            {
32                let len = cmp::min(seq.size_hint().unwrap_or(0), 4096);
33                let mut values = Vec::with_capacity(len);
34
35                while let Some(value) = seq.next_element()? {
36                    values.push(value);
37                }
38
39                Ok(values.into())
40            }
41
42            #[inline]
43            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
44            where
45                E: de::Error,
46            {
47                Ok($ty::$from_slice(v))
48            }
49
50            #[inline]
51            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
52            where
53                E: de::Error,
54            {
55                Ok($ty::from(v))
56            }
57
58            #[inline]
59            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
60            where
61                E: de::Error,
62            {
63                Ok($ty::$from_slice(v.as_bytes()))
64            }
65
66            #[inline]
67            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
68            where
69                E: de::Error,
70            {
71                Ok($ty::from(v))
72            }
73        }
74
75        impl<'de> Deserialize<'de> for $ty {
76            #[inline]
77            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
78            where
79                D: Deserializer<'de>,
80            {
81                deserializer.deserialize_byte_buf($visitor_ty)
82            }
83        }
84    };
85}
86
87serde_impl!(Bytes, BytesVisitor, copy_from_slice);
88serde_impl!(BytesMut, BytesMutVisitor, from);
89
90#[cfg(test)]
91mod tests {
92    use super::*;
93
94    #[test]
95    fn test_serialize() {
96        let s: Bytes = serde_json::from_str(r#""nice bytes""#).unwrap();
97        assert_eq!(s, "nice bytes");
98        let s: BytesMut = serde_json::from_str(r#""nice bytes""#).unwrap();
99        assert_eq!(s, "nice bytes");
100    }
101
102    #[test]
103    fn test_deserialize() {
104        let s = serde_json::to_string(&Bytes::from_static(b"nice bytes")).unwrap();
105        assert_eq!(s, "[110,105,99,101,32,98,121,116,101,115]");
106        let s = serde_json::to_string(&BytesMut::copy_from_slice(b"nice bytes")).unwrap();
107        assert_eq!(s, "[110,105,99,101,32,98,121,116,101,115]");
108    }
109}
ntex_bytes/serde.rs

ntex_bytes/
serde.rs
