scuffle_bytes_util/cow/bytes/
serde.rs

1use super::BytesCow;
2
3impl serde::Serialize for BytesCow<'_> {
4    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
5    where
6        S: serde::Serializer,
7    {
8        serializer.serialize_bytes(self.as_bytes())
9    }
10}
11
12impl<'de> serde::Deserialize<'de> for BytesCow<'de> {
13    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
14    where
15        D: serde::Deserializer<'de>,
16    {
17        struct BytesCowVisitor;
18
19        impl<'de> serde::de::Visitor<'de> for BytesCowVisitor {
20            type Value = BytesCow<'de>;
21
22            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
23                formatter.write_str("a byte slice")
24            }
25
26            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
27            where
28                E: serde::de::Error,
29            {
30                Ok(BytesCow::from_vec(v))
31            }
32
33            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
34            where
35                E: serde::de::Error,
36            {
37                Ok(BytesCow::from_vec(v.to_vec()))
38            }
39
40            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
41            where
42                E: serde::de::Error,
43            {
44                Ok(BytesCow::from_vec(v.as_bytes().to_vec()))
45            }
46
47            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
48            where
49                E: serde::de::Error,
50            {
51                Ok(BytesCow::from_vec(v.into_bytes()))
52            }
53
54            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
55            where
56                E: serde::de::Error,
57            {
58                Ok(BytesCow::from_slice(v))
59            }
60
61            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
62            where
63                E: serde::de::Error,
64            {
65                Ok(BytesCow::from_slice(v.as_bytes()))
66            }
67        }
68
69        deserializer.deserialize_bytes(BytesCowVisitor)
70    }
71}
72
73#[cfg(test)]
74#[cfg_attr(all(test, coverage_nightly), coverage(off))]
75mod tests {
76    use std::fmt::Display;
77
78    use serde::ser::Impossible;
79    use serde::{Deserialize, Serialize};
80
81    use crate::BytesCow;
82
83    #[test]
84    fn serialize() {
85        #[derive(Debug)]
86        struct TestError;
87
88        impl Display for TestError {
89            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
90                write!(f, "Test error")
91            }
92        }
93
94        impl std::error::Error for TestError {}
95
96        impl serde::ser::Error for TestError {
97            fn custom<T: std::fmt::Display>(msg: T) -> Self {
98                panic!("{}", msg)
99            }
100        }
101
102        struct TestSerializer;
103
104        impl serde::Serializer for TestSerializer {
105            type Error = TestError;
106            type Ok = ();
107            type SerializeMap = Impossible<(), Self::Error>;
108            type SerializeSeq = Impossible<(), Self::Error>;
109            type SerializeStruct = Impossible<(), Self::Error>;
110            type SerializeStructVariant = Impossible<(), Self::Error>;
111            type SerializeTuple = Impossible<(), Self::Error>;
112            type SerializeTupleStruct = Impossible<(), Self::Error>;
113            type SerializeTupleVariant = Impossible<(), Self::Error>;
114
115            fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
116                panic!("BytesCow must be serialized as bytes")
117            }
118
119            fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
120                panic!("BytesCow must be serialized as bytes")
121            }
122
123            fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
124                panic!("BytesCow must be serialized as bytes")
125            }
126
127            fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
128                panic!("BytesCow must be serialized as bytes")
129            }
130
131            fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
132                panic!("BytesCow must be serialized as bytes")
133            }
134
135            fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
136                panic!("BytesCow must be serialized as bytes")
137            }
138
139            fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
140                panic!("BytesCow must be serialized as bytes")
141            }
142
143            fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
144                panic!("BytesCow must be serialized as bytes")
145            }
146
147            fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
148                panic!("BytesCow must be serialized as bytes")
149            }
150
151            fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
152                panic!("BytesCow must be serialized as bytes")
153            }
154
155            fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
156                panic!("BytesCow must be serialized as bytes")
157            }
158
159            fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
160                panic!("BytesCow must be serialized as bytes")
161            }
162
163            fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
164                panic!("BytesCow must be serialized as bytes")
165            }
166
167            fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
168                assert_eq!(v, b"hello");
169                Ok(())
170            }
171
172            fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
173                panic!("BytesCow must be serialized as bytes")
174            }
175
176            fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
177            where
178                T: serde::Serialize + ?Sized,
179            {
180                panic!("BytesCow must be serialized as bytes")
181            }
182
183            fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
184                panic!("BytesCow must be serialized as bytes")
185            }
186
187            fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
188                panic!("BytesCow must be serialized as bytes")
189            }
190
191            fn serialize_unit_variant(
192                self,
193                _name: &'static str,
194                _variant_index: u32,
195                _variant: &'static str,
196            ) -> Result<Self::Ok, Self::Error> {
197                panic!("BytesCow must be serialized as bytes")
198            }
199
200            fn serialize_newtype_variant<T>(
201                self,
202                _name: &'static str,
203                _variant_index: u32,
204                _variant: &'static str,
205                _value: &T,
206            ) -> Result<Self::Ok, Self::Error>
207            where
208                T: serde::Serialize + ?Sized,
209            {
210                panic!("BytesCow must be serialized as bytes")
211            }
212
213            fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
214                panic!("BytesCow must be serialized as bytes")
215            }
216
217            fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
218                panic!("BytesCow must be serialized as bytes")
219            }
220
221            fn serialize_tuple_struct(
222                self,
223                _name: &'static str,
224                _len: usize,
225            ) -> Result<Self::SerializeTupleStruct, Self::Error> {
226                panic!("BytesCow must be serialized as bytes")
227            }
228
229            fn serialize_tuple_variant(
230                self,
231                _name: &'static str,
232                _variant_index: u32,
233                _variant: &'static str,
234                _len: usize,
235            ) -> Result<Self::SerializeTupleVariant, Self::Error> {
236                panic!("BytesCow must be serialized as bytes")
237            }
238
239            fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
240                panic!("BytesCow must be serialized as bytes")
241            }
242
243            fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
244                panic!("BytesCow must be serialized as bytes")
245            }
246
247            fn serialize_struct_variant(
248                self,
249                _name: &'static str,
250                _variant_index: u32,
251                _variant: &'static str,
252                _len: usize,
253            ) -> Result<Self::SerializeStructVariant, Self::Error> {
254                panic!("BytesCow must be serialized as bytes")
255            }
256
257            fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<Self::Ok, Self::Error>
258            where
259                T: ?Sized + serde::Serialize,
260            {
261                panic!("BytesCow must be serialized as bytes")
262            }
263        }
264
265        let cow = BytesCow::from_slice(b"hello");
266        let serializer = TestSerializer;
267        cow.serialize(serializer).expect("serialization failed");
268    }
269
270    #[test]
271    fn deserialize() {
272        #[derive(Debug)]
273        struct TestError;
274
275        impl Display for TestError {
276            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
277                write!(f, "Test error")
278            }
279        }
280
281        impl std::error::Error for TestError {}
282
283        impl serde::de::Error for TestError {
284            fn custom<T: std::fmt::Display>(msg: T) -> Self {
285                assert_eq!(msg.to_string(), "invalid type: Option value, expected a byte slice");
286                Self
287            }
288        }
289
290        enum Mode {
291            ByteBuf,
292            Bytes,
293            Str,
294            String,
295            BorrowedBytes,
296            BorrowedStr,
297            None,
298        }
299
300        struct TestDeserializer {
301            mode: Mode,
302        }
303
304        impl<'de> serde::Deserializer<'de> for TestDeserializer {
305            type Error = TestError;
306
307            serde::forward_to_deserialize_any! {
308                bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes byte_buf
309                option unit unit_struct newtype_struct seq tuple tuple_struct
310                map struct enum identifier ignored_any
311            }
312
313            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
314            where
315                V: serde::de::Visitor<'de>,
316            {
317                match self.mode {
318                    Mode::ByteBuf => visitor.visit_byte_buf(vec![b'h', b'e', b'l', b'l', b'o']),
319                    Mode::Bytes => visitor.visit_bytes(b"hello"),
320                    Mode::Str => visitor.visit_str("hello"),
321                    Mode::String => visitor.visit_string("hello".to_owned()),
322                    Mode::BorrowedBytes => visitor.visit_borrowed_bytes(b"hello"),
323                    Mode::BorrowedStr => visitor.visit_borrowed_str("hello"),
324                    Mode::None => visitor.visit_none(),
325                }
326            }
327        }
328
329        fn test_de(de: TestDeserializer) {
330            let cow = BytesCow::deserialize(de).expect("deserialization failed");
331            assert_eq!(cow.as_bytes(), b"hello");
332        }
333
334        test_de(TestDeserializer { mode: Mode::ByteBuf });
335        test_de(TestDeserializer { mode: Mode::Bytes });
336        test_de(TestDeserializer { mode: Mode::Str });
337        test_de(TestDeserializer { mode: Mode::String });
338        test_de(TestDeserializer {
339            mode: Mode::BorrowedBytes,
340        });
341        test_de(TestDeserializer { mode: Mode::BorrowedStr });
342
343        BytesCow::deserialize(TestDeserializer { mode: Mode::None }).expect_err("deserialization should fail");
344    }
345}
scuffle_bytes_util/cow/bytes/serde.rs

scuffle_bytes_util/cow/bytes/
serde.rs
