serde_bytes_repr/
deserializer.rs

1use crate::{ByteFmtDeserializer, ByteFormat};
2use base64::Engine;
3use serde::de;
4use std::fmt;
5
6impl<'de, D> de::Deserializer<'de> for ByteFmtDeserializer<D>
7where
8    D: de::Deserializer<'de>,
9{
10    type Error = D::Error;
11
12    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
13    where
14        V: de::Visitor<'de>,
15    {
16        self.inner.deserialize_any(Visitor::new(visitor, self.fmt))
17    }
18
19    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D::Error>
20    where
21        V: de::Visitor<'de>,
22    {
23        self.inner.deserialize_bool(Visitor::new(visitor, self.fmt))
24    }
25
26    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, D::Error>
27    where
28        V: de::Visitor<'de>,
29    {
30        self.inner.deserialize_u8(Visitor::new(visitor, self.fmt))
31    }
32
33    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, D::Error>
34    where
35        V: de::Visitor<'de>,
36    {
37        self.inner.deserialize_u16(Visitor::new(visitor, self.fmt))
38    }
39
40    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, D::Error>
41    where
42        V: de::Visitor<'de>,
43    {
44        self.inner.deserialize_u32(Visitor::new(visitor, self.fmt))
45    }
46
47    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, D::Error>
48    where
49        V: de::Visitor<'de>,
50    {
51        self.inner.deserialize_u64(Visitor::new(visitor, self.fmt))
52    }
53
54    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, D::Error>
55    where
56        V: de::Visitor<'de>,
57    {
58        self.inner.deserialize_u128(Visitor::new(visitor, self.fmt))
59    }
60
61    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D::Error>
62    where
63        V: de::Visitor<'de>,
64    {
65        self.inner.deserialize_i8(Visitor::new(visitor, self.fmt))
66    }
67
68    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D::Error>
69    where
70        V: de::Visitor<'de>,
71    {
72        self.inner.deserialize_i16(Visitor::new(visitor, self.fmt))
73    }
74
75    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D::Error>
76    where
77        V: de::Visitor<'de>,
78    {
79        self.inner.deserialize_i32(Visitor::new(visitor, self.fmt))
80    }
81
82    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D::Error>
83    where
84        V: de::Visitor<'de>,
85    {
86        self.inner.deserialize_i64(Visitor::new(visitor, self.fmt))
87    }
88
89    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, D::Error>
90    where
91        V: de::Visitor<'de>,
92    {
93        self.inner.deserialize_i128(Visitor::new(visitor, self.fmt))
94    }
95
96    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D::Error>
97    where
98        V: de::Visitor<'de>,
99    {
100        self.inner.deserialize_f32(Visitor::new(visitor, self.fmt))
101    }
102
103    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D::Error>
104    where
105        V: de::Visitor<'de>,
106    {
107        self.inner.deserialize_f64(Visitor::new(visitor, self.fmt))
108    }
109
110    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D::Error>
111    where
112        V: de::Visitor<'de>,
113    {
114        self.inner.deserialize_char(Visitor::new(visitor, self.fmt))
115    }
116
117    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D::Error>
118    where
119        V: de::Visitor<'de>,
120    {
121        self.inner.deserialize_str(Visitor::new(visitor, self.fmt))
122    }
123
124    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D::Error>
125    where
126        V: de::Visitor<'de>,
127    {
128        self.inner
129            .deserialize_string(Visitor::new(visitor, self.fmt))
130    }
131
132    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D::Error>
133    where
134        V: de::Visitor<'de>,
135    {
136        self.inner
137            .deserialize_bytes(Visitor::new(visitor, self.fmt))
138    }
139
140    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D::Error>
141    where
142        V: de::Visitor<'de>,
143    {
144        self.inner
145            .deserialize_byte_buf(Visitor::new(visitor, self.fmt))
146    }
147
148    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D::Error>
149    where
150        V: de::Visitor<'de>,
151    {
152        self.inner
153            .deserialize_option(Visitor::new(visitor, self.fmt))
154    }
155
156    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D::Error>
157    where
158        V: de::Visitor<'de>,
159    {
160        self.inner.deserialize_unit(Visitor::new(visitor, self.fmt))
161    }
162
163    fn deserialize_unit_struct<V>(
164        self,
165        name: &'static str,
166        visitor: V,
167    ) -> Result<V::Value, D::Error>
168    where
169        V: de::Visitor<'de>,
170    {
171        self.inner
172            .deserialize_unit_struct(name, Visitor::new(visitor, self.fmt))
173    }
174
175    fn deserialize_newtype_struct<V>(
176        self,
177        name: &'static str,
178        visitor: V,
179    ) -> Result<V::Value, D::Error>
180    where
181        V: de::Visitor<'de>,
182    {
183        self.inner
184            .deserialize_newtype_struct(name, Visitor::new(visitor, self.fmt))
185    }
186
187    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>
188    where
189        V: de::Visitor<'de>,
190    {
191        self.inner.deserialize_seq(Visitor::new(visitor, self.fmt))
192    }
193
194    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
195    where
196        V: de::Visitor<'de>,
197    {
198        self.inner
199            .deserialize_tuple(len, Visitor::new(visitor, self.fmt))
200    }
201
202    fn deserialize_tuple_struct<V>(
203        self,
204        name: &'static str,
205        len: usize,
206        visitor: V,
207    ) -> Result<V::Value, D::Error>
208    where
209        V: de::Visitor<'de>,
210    {
211        self.inner
212            .deserialize_tuple_struct(name, len, Visitor::new(visitor, self.fmt))
213    }
214
215    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>
216    where
217        V: de::Visitor<'de>,
218    {
219        self.inner.deserialize_map(Visitor::new(visitor, self.fmt))
220    }
221
222    fn deserialize_struct<V>(
223        self,
224        name: &'static str,
225        fields: &'static [&'static str],
226        visitor: V,
227    ) -> Result<V::Value, D::Error>
228    where
229        V: de::Visitor<'de>,
230    {
231        self.inner
232            .deserialize_struct(name, fields, Visitor::new(visitor, self.fmt))
233    }
234
235    fn deserialize_enum<V>(
236        self,
237        name: &'static str,
238        variants: &'static [&'static str],
239        visitor: V,
240    ) -> Result<V::Value, D::Error>
241    where
242        V: de::Visitor<'de>,
243    {
244        self.inner
245            .deserialize_enum(name, variants, Visitor::new(visitor, self.fmt))
246    }
247
248    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
249    where
250        V: de::Visitor<'de>,
251    {
252        self.inner
253            .deserialize_ignored_any(Visitor::new(visitor, self.fmt))
254    }
255
256    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>
257    where
258        V: de::Visitor<'de>,
259    {
260        self.inner
261            .deserialize_identifier(Visitor::new(visitor, self.fmt))
262    }
263
264    fn is_human_readable(&self) -> bool {
265        self.inner.is_human_readable()
266    }
267}
268
269struct Visitor<V> {
270    delegate: V,
271    fmt: ByteFormat,
272}
273
274impl<V> Visitor<V> {
275    fn new(delegate: V, format: ByteFormat) -> Self {
276        Visitor {
277            delegate,
278            fmt: format,
279        }
280    }
281
282    fn decode<E>(&self, v: &[u8]) -> Result<Vec<u8>, E>
283    where
284        E: de::Error,
285    {
286        match self.fmt {
287            ByteFormat::Base64(ref alphabet, config) => {
288                match base64::engine::GeneralPurpose::new(alphabet, config).decode(v) {
289                    Ok(bytes) => Ok(bytes),
290                    Err(base64::DecodeError::InvalidByte(index, b)) => Err(E::invalid_value(
291                        de::Unexpected::Char(b.into()),
292                        &format!("valid base64 character at index {}", index).as_str(),
293                    )),
294                    Err(base64::DecodeError::InvalidLength(_)) => {
295                        Err(E::invalid_length(v.len(), &"valid base64 length"))
296                    }
297                    Err(base64::DecodeError::InvalidLastSymbol(_, b)) => Err(E::invalid_value(
298                        de::Unexpected::Char(b.into()),
299                        &"valid character ending base64 string",
300                    )),
301                    Err(base64::DecodeError::InvalidPadding) => Err(E::invalid_value(
302                        de::Unexpected::Other("invalid padding"),
303                        &"valid padding",
304                    )),
305                }
306            }
307            ByteFormat::Hex => match hex::decode(v) {
308                Ok(bytes) => Ok(bytes),
309                Err(hex::FromHexError::OddLength) => {
310                    Err(E::invalid_length(v.len(), &"even length"))
311                }
312                Err(hex::FromHexError::InvalidHexCharacter { c, index }) => Err(E::invalid_value(
313                    de::Unexpected::Char(c),
314                    &format!("valid hex character at index {}", index).as_str(),
315                )),
316                Err(hex::FromHexError::InvalidStringLength) => Err(E::custom(
317                    "Imposible to reach due to unrestricted return length",
318                )),
319            },
320        }
321    }
322}
323
324impl<'de, V> de::Visitor<'de> for Visitor<V>
325where
326    V: de::Visitor<'de>,
327{
328    type Value = V::Value;
329
330    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
331        self.delegate.expecting(formatter)
332    }
333
334    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
335    where
336        E: de::Error,
337    {
338        self.delegate.visit_bool(v)
339    }
340
341    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
342    where
343        E: de::Error,
344    {
345        self.delegate.visit_i8(v)
346    }
347
348    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
349    where
350        E: de::Error,
351    {
352        self.delegate.visit_i16(v)
353    }
354
355    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
356    where
357        E: de::Error,
358    {
359        self.delegate.visit_i32(v)
360    }
361
362    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
363    where
364        E: de::Error,
365    {
366        self.delegate.visit_i64(v)
367    }
368
369    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
370    where
371        E: de::Error,
372    {
373        self.delegate.visit_i128(v)
374    }
375
376    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
377    where
378        E: de::Error,
379    {
380        self.delegate.visit_u8(v)
381    }
382
383    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
384    where
385        E: de::Error,
386    {
387        self.delegate.visit_u16(v)
388    }
389
390    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
391    where
392        E: de::Error,
393    {
394        self.delegate.visit_u32(v)
395    }
396
397    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
398    where
399        E: de::Error,
400    {
401        self.delegate.visit_u64(v)
402    }
403
404    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
405    where
406        E: de::Error,
407    {
408        self.delegate.visit_u128(v)
409    }
410
411    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
412    where
413        E: de::Error,
414    {
415        self.delegate.visit_f32(v)
416    }
417
418    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
419    where
420        E: de::Error,
421    {
422        self.delegate.visit_f64(v)
423    }
424
425    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
426    where
427        E: de::Error,
428    {
429        self.delegate.visit_char(v)
430    }
431
432    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
433    where
434        E: de::Error,
435    {
436        self.delegate.visit_str(v)
437    }
438
439    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
440    where
441        E: de::Error,
442    {
443        self.delegate.visit_borrowed_str(v)
444    }
445
446    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
447    where
448        E: de::Error,
449    {
450        self.delegate.visit_string(v)
451    }
452
453    fn visit_unit<E>(self) -> Result<Self::Value, E>
454    where
455        E: de::Error,
456    {
457        self.delegate.visit_unit()
458    }
459
460    fn visit_none<E>(self) -> Result<Self::Value, E>
461    where
462        E: de::Error,
463    {
464        self.delegate.visit_none()
465    }
466
467    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
468    where
469        D: de::Deserializer<'de>,
470    {
471        self.delegate.visit_some(ByteFmtDeserializer {
472            inner: deserializer,
473            fmt: self.fmt,
474        })
475    }
476
477    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
478    where
479        D: de::Deserializer<'de>,
480    {
481        self.delegate.visit_newtype_struct(ByteFmtDeserializer {
482            inner: deserializer,
483            fmt: self.fmt,
484        })
485    }
486
487    fn visit_seq<A>(self, visitor: A) -> Result<Self::Value, A::Error>
488    where
489        A: de::SeqAccess<'de>,
490    {
491        self.delegate.visit_seq(SeqAccess::new(visitor, self.fmt))
492    }
493
494    fn visit_map<A>(self, visitor: A) -> Result<Self::Value, A::Error>
495    where
496        A: de::MapAccess<'de>,
497    {
498        self.delegate.visit_map(MapAccess::new(visitor, self.fmt))
499    }
500
501    fn visit_enum<A>(self, visitor: A) -> Result<Self::Value, A::Error>
502    where
503        A: de::EnumAccess<'de>,
504    {
505        self.delegate.visit_enum(EnumAccess::new(visitor, self.fmt))
506    }
507
508    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
509    where
510        E: de::Error,
511    {
512        let decoded = self.decode(v)?;
513        self.delegate.visit_bytes(&decoded)
514    }
515
516    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
517    where
518        E: de::Error,
519    {
520        // TODO: Check if there is any way we can do zero copy deserialization
521        self.visit_bytes(v)
522    }
523
524    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
525    where
526        E: de::Error,
527    {
528        let decoded = self.decode(&v)?;
529        self.delegate.visit_byte_buf(decoded)
530    }
531}
532
533struct EnumAccess<D> {
534    delegate: D,
535    fmt: ByteFormat,
536}
537
538impl<D> EnumAccess<D> {
539    fn new(delegate: D, fmt: ByteFormat) -> Self {
540        EnumAccess { delegate, fmt }
541    }
542}
543
544impl<'de, D> de::EnumAccess<'de> for EnumAccess<D>
545where
546    D: de::EnumAccess<'de>,
547{
548    type Error = D::Error;
549    type Variant = VariantAccess<D::Variant>;
550
551    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), D::Error>
552    where
553        V: de::DeserializeSeed<'de>,
554    {
555        let fmt = self.fmt;
556        self.delegate
557            .variant_seed(DeserializeSeed::new(seed, fmt.clone()))
558            .map(|(v, vis)| (v, VariantAccess::new(vis, fmt)))
559    }
560}
561
562struct VariantAccess<D> {
563    delegate: D,
564    fmt: ByteFormat,
565}
566
567impl<D> VariantAccess<D> {
568    fn new(delegate: D, fmt: ByteFormat) -> Self {
569        VariantAccess { delegate, fmt }
570    }
571}
572
573impl<'de, D> de::VariantAccess<'de> for VariantAccess<D>
574where
575    D: de::VariantAccess<'de>,
576{
577    type Error = D::Error;
578
579    fn unit_variant(self) -> Result<(), D::Error> {
580        self.delegate.unit_variant()
581    }
582
583    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error>
584    where
585        T: de::DeserializeSeed<'de>,
586    {
587        self.delegate
588            .newtype_variant_seed(DeserializeSeed::new(seed, self.fmt))
589    }
590
591    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
592    where
593        V: de::Visitor<'de>,
594    {
595        self.delegate
596            .tuple_variant(len, Visitor::new(visitor, self.fmt))
597    }
598
599    fn struct_variant<V>(
600        self,
601        fields: &'static [&'static str],
602        visitor: V,
603    ) -> Result<V::Value, D::Error>
604    where
605        V: de::Visitor<'de>,
606    {
607        self.delegate
608            .struct_variant(fields, Visitor::new(visitor, self.fmt))
609    }
610}
611
612struct DeserializeSeed<S> {
613    delegate: S,
614    fmt: ByteFormat,
615}
616
617impl<S> DeserializeSeed<S> {
618    fn new(delegate: S, fmt: ByteFormat) -> Self {
619        DeserializeSeed { delegate, fmt }
620    }
621}
622
623impl<'de, S> de::DeserializeSeed<'de> for DeserializeSeed<S>
624where
625    S: de::DeserializeSeed<'de>,
626{
627    type Value = S::Value;
628
629    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
630    where
631        D: de::Deserializer<'de>,
632    {
633        self.delegate.deserialize(ByteFmtDeserializer {
634            inner: deserializer,
635            fmt: self.fmt,
636        })
637    }
638}
639
640struct SeqAccess<D> {
641    delegate: D,
642    fmt: ByteFormat,
643}
644
645impl<D> SeqAccess<D> {
646    fn new(delegate: D, fmt: ByteFormat) -> Self {
647        SeqAccess { delegate, fmt }
648    }
649}
650
651impl<'de, D> de::SeqAccess<'de> for SeqAccess<D>
652where
653    D: de::SeqAccess<'de>,
654{
655    type Error = D::Error;
656
657    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, D::Error>
658    where
659        T: de::DeserializeSeed<'de>,
660    {
661        self.delegate
662            .next_element_seed(DeserializeSeed::new(seed, self.fmt.clone()))
663    }
664
665    fn size_hint(&self) -> Option<usize> {
666        self.delegate.size_hint()
667    }
668}
669
670struct MapAccess<D> {
671    delegate: D,
672    fmt: ByteFormat,
673}
674
675impl<D> MapAccess<D> {
676    fn new(delegate: D, fmt: ByteFormat) -> Self {
677        MapAccess { delegate, fmt }
678    }
679}
680
681impl<'de, D> de::MapAccess<'de> for MapAccess<D>
682where
683    D: de::MapAccess<'de>,
684{
685    type Error = D::Error;
686
687    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error>
688    where
689        K: de::DeserializeSeed<'de>,
690    {
691        self.delegate
692            .next_key_seed(DeserializeSeed::new(seed, self.fmt.clone()))
693    }
694
695    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error>
696    where
697        V: de::DeserializeSeed<'de>,
698    {
699        self.delegate
700            .next_value_seed(DeserializeSeed::new(seed, self.fmt.clone()))
701    }
702
703    fn size_hint(&self) -> Option<usize> {
704        self.delegate.size_hint()
705    }
706}
serde_bytes_repr/deserializer.rs

serde_bytes_repr/
deserializer.rs
