1use core::fmt::Display;
2
3use serde::de::{DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
4use serde::ser::{
5 SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
6 SerializeTupleStruct, SerializeTupleVariant,
7};
8use serde::{de, ser, Deserializer, Serialize, Serializer};
9
10use crate::io::{Read, Write};
11use crate::{Encode, Encoder, EncodingError};
12
13fn serde_error(_msg: &'static str) -> EncodingError {
14 #[cfg(feature = "alloc")]
15 {
16 EncodingError::SerdeError(<&str as alloc::string::ToString>::to_string(&_msg))
17 }
18 #[cfg(not(feature = "alloc"))]
19 {
20 EncodingError::SerdeError
21 }
22}
23
24impl ser::Error for EncodingError {
25 fn custom<Msg>(_msg: Msg) -> Self
26 where
27 Msg: Display,
28 {
29 #[cfg(feature = "alloc")]
30 {
31 Self::SerdeError(<Msg as alloc::string::ToString>::to_string(&_msg))
32 }
33 #[cfg(not(feature = "alloc"))]
34 {
35 Self::SerdeError
36 }
37 }
38}
39
40impl de::Error for EncodingError {
41 fn custom<Msg>(_msg: Msg) -> Self
42 where
43 Msg: Display,
44 {
45 #[cfg(feature = "alloc")]
46 {
47 Self::SerdeError(<Msg as alloc::string::ToString>::to_string(&_msg))
48 }
49 #[cfg(not(feature = "alloc"))]
50 {
51 Self::SerdeError
52 }
53 }
54}
55
56impl<T: Write> Serializer for &mut Encoder<'_, T> {
57 type Ok = ();
58 type Error = EncodingError;
59 type SerializeSeq = Self;
60 type SerializeTuple = Self;
61 type SerializeTupleStruct = Self;
62 type SerializeTupleVariant = Self;
63 type SerializeMap = Self;
64 type SerializeStruct = Self;
65 type SerializeStructVariant = Self;
66
67 fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
68 self.write_bool(v)
69 }
70
71 fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
72 self.write_i8(v)
73 }
74
75 fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
76 self.write_i16(v)
77 }
78
79 fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
80 self.write_i32(v)
81 }
82
83 fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
84 self.write_i64(v)
85 }
86
87 fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
88 self.write_i128(v)
89 }
90
91 fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
92 self.write_u8(v)
93 }
94
95 fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
96 self.write_u16(v)
97 }
98
99 fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
100 self.write_u32(v)
101 }
102
103 fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
104 self.write_u64(v)
105 }
106
107 fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
108 self.write_u128(v)
109 }
110
111 fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
112 self.write_f32(v)
113 }
114
115 fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
116 self.write_f64(v)
117 }
118
119 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
120 self.write_char(v)
121 }
122
123 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
124 v.encode(self)
125 }
126
127 #[cfg(not(feature = "alloc"))]
128 fn collect_str<G: ?Sized>(self, _value: &G) -> Result<Self::Ok, Self::Error>
129 where
130 G: Display,
131 {
132 Err(serde_error(
133 "Types implementing Display cannot be serialized without the alloc feature",
134 ))
135 }
136
137 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
138 self.write_usize(v.len())?;
139 self.write_bytes(v)
140 }
141
142 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
143 self.write_bool(false)?;
144 Ok(())
145 }
146
147 fn serialize_some<G: ?Sized>(self, value: &G) -> Result<Self::Ok, Self::Error>
148 where
149 G: Serialize,
150 {
151 self.write_bool(true)?;
152 value.serialize(self)
153 }
154
155 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
156 Ok(())
157 }
158
159 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
160 Ok(())
161 }
162
163 fn serialize_unit_variant(
164 self,
165 _name: &'static str,
166 variant_index: u32,
167 _variant: &'static str,
168 ) -> Result<Self::Ok, Self::Error> {
169 self.write_uvariant(variant_index)
170 }
171
172 fn serialize_newtype_struct<G: ?Sized>(
173 self,
174 _name: &'static str,
175 value: &G,
176 ) -> Result<Self::Ok, Self::Error>
177 where
178 G: Serialize,
179 {
180 value.serialize(self)
181 }
182
183 fn serialize_newtype_variant<G: ?Sized>(
184 self,
185 _name: &'static str,
186 variant_index: u32,
187 _variant: &'static str,
188 value: &G,
189 ) -> Result<Self::Ok, Self::Error>
190 where
191 G: Serialize,
192 {
193 self.write_uvariant(variant_index)?;
194 value.serialize(self)
195 }
196
197 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
198 let len = len.ok_or(serde_error("Length must be known upfront"))?;
199 self.write_usize(len)?;
200 Ok(self)
201 }
202
203 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
204 Ok(self)
205 }
206
207 fn serialize_tuple_struct(
208 self,
209 _name: &'static str,
210 _len: usize,
211 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
212 Ok(self)
213 }
214
215 fn serialize_tuple_variant(
216 self,
217 _name: &'static str,
218 variant_index: u32,
219 _variant: &'static str,
220 _len: usize,
221 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
222 self.write_uvariant(variant_index)?;
223 Ok(self)
224 }
225
226 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
227 let len = len.ok_or(serde_error("Length must be known upfront"))?;
228 self.write_usize(len)?;
229 Ok(self)
230 }
231
232 fn serialize_struct(
233 self,
234 _name: &'static str,
235 _len: usize,
236 ) -> Result<Self::SerializeStruct, Self::Error> {
237 Ok(self)
238 }
239
240 fn serialize_struct_variant(
241 self,
242 _name: &'static str,
243 variant_index: u32,
244 _variant: &'static str,
245 _len: usize,
246 ) -> Result<Self::SerializeStructVariant, Self::Error> {
247 self.write_uvariant(variant_index)?;
248 Ok(self)
249 }
250
251 fn is_human_readable(&self) -> bool {
252 false
253 }
254}
255
256impl<T: Write> SerializeSeq for &mut Encoder<'_, T> {
257 type Ok = ();
258 type Error = EncodingError;
259
260 fn serialize_element<G: ?Sized>(&mut self, value: &G) -> Result<(), Self::Error>
261 where
262 G: Serialize,
263 {
264 value.serialize(&mut **self)
265 }
266
267 fn end(self) -> Result<Self::Ok, Self::Error> {
268 Ok(())
269 }
270}
271
272impl<T: Write> SerializeTuple for &mut Encoder<'_, T> {
273 type Ok = ();
274 type Error = EncodingError;
275
276 fn serialize_element<G: ?Sized>(&mut self, value: &G) -> Result<(), Self::Error>
277 where
278 G: Serialize,
279 {
280 value.serialize(&mut **self)
281 }
282
283 fn end(self) -> Result<Self::Ok, Self::Error> {
284 Ok(())
285 }
286}
287
288impl<T: Write> SerializeTupleStruct for &mut Encoder<'_, T> {
289 type Ok = ();
290 type Error = EncodingError;
291
292 fn serialize_field<G: ?Sized>(&mut self, value: &G) -> Result<(), Self::Error>
293 where
294 G: Serialize,
295 {
296 value.serialize(&mut **self)
297 }
298
299 fn end(self) -> Result<Self::Ok, Self::Error> {
300 Ok(())
301 }
302}
303
304impl<T: Write> SerializeTupleVariant for &mut Encoder<'_, T> {
305 type Ok = ();
306 type Error = EncodingError;
307
308 fn serialize_field<G: ?Sized>(&mut self, value: &G) -> Result<(), Self::Error>
309 where
310 G: Serialize,
311 {
312 value.serialize(&mut **self)
313 }
314
315 fn end(self) -> Result<Self::Ok, Self::Error> {
316 Ok(())
317 }
318}
319
320impl<T: Write> SerializeMap for &mut Encoder<'_, T> {
321 type Ok = ();
322 type Error = EncodingError;
323
324 fn serialize_key<G: ?Sized>(&mut self, key: &G) -> Result<(), Self::Error>
325 where
326 G: Serialize,
327 {
328 key.serialize(&mut **self)
329 }
330
331 fn serialize_value<G: ?Sized>(&mut self, value: &G) -> Result<(), Self::Error>
332 where
333 G: Serialize,
334 {
335 value.serialize(&mut **self)
336 }
337
338 fn end(self) -> Result<Self::Ok, Self::Error> {
339 Ok(())
340 }
341}
342
343impl<T: Write> SerializeStruct for &mut Encoder<'_, T> {
344 type Ok = ();
345 type Error = EncodingError;
346
347 fn serialize_field<G: ?Sized>(
348 &mut self,
349 _key: &'static str,
350 value: &G,
351 ) -> Result<(), Self::Error>
352 where
353 G: Serialize,
354 {
355 value.serialize(&mut **self)
356 }
357
358 fn end(self) -> Result<Self::Ok, Self::Error> {
359 Ok(())
360 }
361}
362
363impl<T: Write> SerializeStructVariant for &mut Encoder<'_, T> {
364 type Ok = ();
365 type Error = EncodingError;
366
367 fn serialize_field<G: ?Sized>(
368 &mut self,
369 _key: &'static str,
370 value: &G,
371 ) -> Result<(), Self::Error>
372 where
373 G: Serialize,
374 {
375 value.serialize(&mut **self)
376 }
377
378 fn end(self) -> Result<Self::Ok, Self::Error> {
379 Ok(())
380 }
381}
382
383impl<'de, T: Read> Deserializer<'de> for &mut Encoder<'de, T> {
384 type Error = EncodingError;
385
386 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
387 where
388 V: Visitor<'de>,
389 {
390 Err(serde_error(
391 "deserialize_any: This data format is non-describing",
392 ))
393 }
394
395 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
396 where
397 V: Visitor<'de>,
398 {
399 visitor.visit_bool(self.read_bool()?)
400 }
401
402 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
403 where
404 V: Visitor<'de>,
405 {
406 visitor.visit_i8(self.read_i8()?)
407 }
408
409 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
410 where
411 V: Visitor<'de>,
412 {
413 visitor.visit_i16(self.read_i16()?)
414 }
415
416 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
417 where
418 V: Visitor<'de>,
419 {
420 visitor.visit_i32(self.read_i32()?)
421 }
422
423 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
424 where
425 V: Visitor<'de>,
426 {
427 visitor.visit_i64(self.read_i64()?)
428 }
429
430 fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
431 where
432 V: Visitor<'de>,
433 {
434 visitor.visit_i128(self.read_i128()?)
435 }
436
437 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
438 where
439 V: Visitor<'de>,
440 {
441 visitor.visit_u8(self.read_u8()?)
442 }
443
444 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
445 where
446 V: Visitor<'de>,
447 {
448 visitor.visit_u16(self.read_u16()?)
449 }
450
451 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
452 where
453 V: Visitor<'de>,
454 {
455 visitor.visit_u32(self.read_u32()?)
456 }
457
458 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
459 where
460 V: Visitor<'de>,
461 {
462 visitor.visit_u64(self.read_u64()?)
463 }
464
465 fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
466 where
467 V: Visitor<'de>,
468 {
469 visitor.visit_u128(self.read_u128()?)
470 }
471
472 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
473 where
474 V: Visitor<'de>,
475 {
476 visitor.visit_f32(self.read_f32()?)
477 }
478
479 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
480 where
481 V: Visitor<'de>,
482 {
483 visitor.visit_f64(self.read_f64()?)
484 }
485
486 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
487 where
488 V: Visitor<'de>,
489 {
490 visitor.visit_char(self.read_char()?)
491 }
492
493 fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
494 where
495 V: Visitor<'de>,
496 {
497 #[cfg(feature = "alloc")]
498 {
499 use crate::Decode;
500 _visitor.visit_str(&alloc::string::String::decode(self)?)
501 }
502 #[cfg(not(feature = "alloc"))]
503 {
504 Err(serde_error(
505 "Zero-copy str decoding without alloc is not supported yet",
506 ))
507 }
508 }
509
510 fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
511 where
512 V: Visitor<'de>,
513 {
514 #[cfg(feature = "alloc")]
515 {
516 use crate::Decode;
517 _visitor.visit_string(alloc::string::String::decode(self)?)
518 }
519 #[cfg(not(feature = "alloc"))]
520 {
521 Err(serde_error(
522 "Zero-copy str decoding without alloc is not supported yet",
523 ))
524 }
525 }
526
527 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
528 where
529 V: Visitor<'de>,
530 {
531 #[cfg(feature = "alloc")]
532 {
533 use crate::Decode;
534 _visitor.visit_bytes(&alloc::vec::Vec::decode(self)?)
535 }
536 #[cfg(not(feature = "alloc"))]
537 {
538 Err(serde_error(
539 "Zero-copy [u8] decoding without alloc is not supported yet",
540 ))
541 }
542 }
543
544 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
545 where
546 V: Visitor<'de>,
547 {
548 #[cfg(feature = "alloc")]
549 {
550 use crate::Decode;
551 _visitor.visit_byte_buf(alloc::vec::Vec::decode(self)?)
552 }
553 #[cfg(not(feature = "alloc"))]
554 {
555 Err(serde_error(
556 "Zero-copy [u8] decoding without alloc is not supported yet",
557 ))
558 }
559 }
560
561 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
562 where
563 V: Visitor<'de>,
564 {
565 if self.read_bool()? {
566 visitor.visit_some(self)
567 } else {
568 visitor.visit_none()
569 }
570 }
571
572 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
573 where
574 V: Visitor<'de>,
575 {
576 visitor.visit_unit()
577 }
578
579 fn deserialize_unit_struct<V>(
580 self,
581 _name: &'static str,
582 visitor: V,
583 ) -> Result<V::Value, Self::Error>
584 where
585 V: Visitor<'de>,
586 {
587 visitor.visit_unit()
588 }
589
590 fn deserialize_newtype_struct<V>(
591 self,
592 _name: &'static str,
593 visitor: V,
594 ) -> Result<V::Value, Self::Error>
595 where
596 V: Visitor<'de>,
597 {
598 visitor.visit_newtype_struct(self)
599 }
600
601 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
602 where
603 V: Visitor<'de>,
604 {
605 let len = self.read_usize()?;
606 visitor.visit_seq(SeqAccessEncoder {
607 encoder: self,
608 length: len,
609 })
610 }
611
612 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
613 where
614 V: Visitor<'de>,
615 {
616 visitor.visit_seq(SeqAccessEncoder {
617 encoder: self,
618 length: len,
619 })
620 }
621
622 fn deserialize_tuple_struct<V>(
623 self,
624 _name: &'static str,
625 len: usize,
626 visitor: V,
627 ) -> Result<V::Value, Self::Error>
628 where
629 V: Visitor<'de>,
630 {
631 visitor.visit_seq(SeqAccessEncoder {
632 encoder: self,
633 length: len,
634 })
635 }
636
637 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
638 where
639 V: Visitor<'de>,
640 {
641 let len = self.read_usize()?;
642 visitor.visit_map(MapAccessEncoder {
643 encoder: self,
644 length: len,
645 })
646 }
647
648 fn deserialize_struct<V>(
649 self,
650 _name: &'static str,
651 fields: &'static [&'static str],
652 visitor: V,
653 ) -> Result<V::Value, Self::Error>
654 where
655 V: Visitor<'de>,
656 {
657 visitor.visit_seq(SeqAccessEncoder {
658 encoder: self,
659 length: fields.len(),
660 })
661 }
662
663 fn deserialize_enum<V>(
664 self,
665 _name: &'static str,
666 _variants: &'static [&'static str],
667 visitor: V,
668 ) -> Result<V::Value, Self::Error>
669 where
670 V: Visitor<'de>,
671 {
672 visitor.visit_enum(self)
673 }
674
675 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
676 where
677 V: Visitor<'de>,
678 {
679 visitor.visit_u32(self.read_uvariant()?)
680 }
681
682 fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
683 where
684 V: Visitor<'de>,
685 {
686 Err(serde_error(
687 "deserialize_ignored_any: This data format is non-describing",
688 ))
689 }
690
691 fn is_human_readable(&self) -> bool {
692 false
693 }
694}
695
696struct SeqAccessEncoder<'a, 'de, T: Read> {
697 encoder: &'a mut Encoder<'de, T>,
698 length: usize,
699}
700
701impl<'de, T: Read> SeqAccess<'de> for SeqAccessEncoder<'_, 'de, T> {
702 type Error = EncodingError;
703
704 fn next_element_seed<G>(&mut self, seed: G) -> Result<Option<G::Value>, Self::Error>
705 where
706 G: DeserializeSeed<'de>,
707 {
708 if self.length != 0 {
709 self.length -= 1;
710 seed.deserialize(&mut *self.encoder).map(Some)
711 } else {
712 Ok(None)
713 }
714 }
715
716 fn size_hint(&self) -> Option<usize> {
717 Some(self.length)
718 }
719}
720
721struct MapAccessEncoder<'a, 'de, T: Read> {
722 encoder: &'a mut Encoder<'de, T>,
723 length: usize,
724}
725
726impl<'de, T: Read> MapAccess<'de> for MapAccessEncoder<'_, 'de, T> {
727 type Error = EncodingError;
728
729 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
730 where
731 K: DeserializeSeed<'de>,
732 {
733 if self.length != 0 {
734 self.length -= 1;
735 seed.deserialize(&mut *self.encoder).map(Some)
736 } else {
737 Ok(None)
738 }
739 }
740
741 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
742 where
743 V: DeserializeSeed<'de>,
744 {
745 seed.deserialize(&mut *self.encoder)
746 }
747
748 fn size_hint(&self) -> Option<usize> {
749 Some(self.length)
750 }
751}
752
753impl<'de, T: Read> EnumAccess<'de> for &mut Encoder<'de, T> {
754 type Error = EncodingError;
755 type Variant = Self;
756
757 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
758 where
759 V: DeserializeSeed<'de>,
760 {
761 let val = seed.deserialize(&mut *self)?;
762 Ok((val, self))
763 }
764}
765
766impl<'de, T: Read> VariantAccess<'de> for &mut Encoder<'de, T> {
767 type Error = EncodingError;
768
769 fn unit_variant(self) -> Result<(), Self::Error> {
770 Ok(())
771 }
772
773 fn newtype_variant_seed<G>(self, seed: G) -> Result<G::Value, Self::Error>
774 where
775 G: DeserializeSeed<'de>,
776 {
777 seed.deserialize(self)
778 }
779
780 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
781 where
782 V: Visitor<'de>,
783 {
784 self.deserialize_tuple(len, visitor)
785 }
786
787 fn struct_variant<V>(
788 self,
789 fields: &'static [&'static str],
790 visitor: V,
791 ) -> Result<V::Value, Self::Error>
792 where
793 V: Visitor<'de>,
794 {
795 self.deserialize_struct("", fields, visitor)
796 }
797}