bincode_next/features/serde/
de_borrowed.rs

1#![allow(deprecated)]
2use crate::config::Config;
3use crate::de::BorrowDecode;
4use crate::de::BorrowDecoder;
5use crate::de::Decode;
6use crate::de::DecoderImpl;
7use crate::de::read::SliceReader;
8use crate::error::DecodeError;
9use core::marker::PhantomData;
10use serde::de::Deserialize;
11use serde::de::DeserializeSeed;
12use serde::de::Deserializer;
13use serde::de::EnumAccess;
14use serde::de::IntoDeserializer;
15use serde::de::MapAccess;
16use serde::de::SeqAccess;
17use serde::de::VariantAccess;
18use serde::de::Visitor;
19
20/// Serde decoder encapsulating a borrowed reader.
21pub struct BorrowedSerdeDecoder<'de, DE: BorrowDecoder<'de>> {
22    pub(super) de: DE,
23    pub(super) pd: PhantomData<&'de ()>,
24}
25
26impl<'de, DE: BorrowDecoder<'de>> BorrowedSerdeDecoder<'de, DE> {
27    /// Return a type implementing `serde::Deserializer`.
28    pub fn as_deserializer<'a>(
29        &'a mut self
30    ) -> impl serde::Deserializer<'de, Error = DecodeError> + 'a {
31        SerdeDecoder {
32            de: &mut self.de,
33            pd: PhantomData,
34        }
35    }
36}
37
38impl<'de, C: Config, Context> BorrowedSerdeDecoder<'de, DecoderImpl<SliceReader<'de>, C, Context>> {
39    /// Creates the decoder from a borrowed slice.
40    pub const fn from_slice(
41        slice: &'de [u8],
42        config: C,
43        context: Context,
44    ) -> Self
45    where
46        C: Config,
47    {
48        let reader = SliceReader::new(slice);
49        let decoder = DecoderImpl::new(reader, config, context);
50        Self {
51            de: decoder,
52            pd: PhantomData,
53        }
54    }
55}
56
57/// Attempt to decode a given type `D` from the given slice. Returns the decoded output and the amount of bytes read.
58///
59/// See the [config](../config/index.html) module for more information on configurations.
60/// # Errors
61///
62/// Returns a `DecodeError` if the slice cannot be decoded.
63pub fn borrow_decode_from_slice<'de, D, C>(
64    slice: &'de [u8],
65    config: C,
66) -> Result<(D, usize), DecodeError>
67where
68    D: Deserialize<'de>,
69    C: Config,
70{
71    let mut serde_decoder =
72        BorrowedSerdeDecoder::<DecoderImpl<SliceReader<'de>, C, ()>>::from_slice(slice, config, ());
73    let result = D::deserialize(serde_decoder.as_deserializer())?;
74    let bytes_read = slice.len() - serde_decoder.de.borrow_reader().slice.len();
75    Ok((result, bytes_read))
76}
77
78/// Decode a borrowed type from the given slice using a seed. Some parts of the decoded type are expected to be referring to the given slice
79/// # Errors
80///
81/// Returns a `DecodeError` if the slice cannot be decoded.
82pub fn seed_decode_from_slice<'de, D, C>(
83    seed: D,
84    slice: &'de [u8],
85    config: C,
86) -> Result<(D::Value, usize), DecodeError>
87where
88    D: DeserializeSeed<'de>,
89    C: Config,
90{
91    let mut serde_decoder =
92        BorrowedSerdeDecoder::<DecoderImpl<SliceReader<'de>, C, ()>>::from_slice(slice, config, ());
93    let result = seed.deserialize(serde_decoder.as_deserializer())?;
94    let bytes_read = slice.len() - serde_decoder.de.borrow_reader().slice.len();
95    Ok((result, bytes_read))
96}
97
98pub(super) struct SerdeDecoder<'a, 'de, DE: BorrowDecoder<'de>> {
99    pub(super) de: &'a mut DE,
100    pub(super) pd: PhantomData<&'de ()>,
101}
102
103impl<'de, DE: BorrowDecoder<'de>> Deserializer<'de> for SerdeDecoder<'_, 'de, DE> {
104    type Error = DecodeError;
105
106    serde::serde_if_integer128! {
107        fn deserialize_i128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
108        where
109            V: serde::de::Visitor<'de>,
110        {
111            visitor.visit_i128(Decode::decode(&mut self.de)?)
112        }
113    }
114
115    serde::serde_if_integer128! {
116        fn deserialize_u128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
117        where
118            V: serde::de::Visitor<'de>,
119        {
120            visitor.visit_u128(Decode::decode(&mut self.de)?)
121        }
122    }
123
124    fn deserialize_any<V>(
125        self,
126        _: V,
127    ) -> Result<V::Value, Self::Error>
128    where
129        V: serde::de::Visitor<'de>,
130    {
131        super::cold_decode_error_any_not_supported::<'de, V>().map_err(core::convert::Into::into)
132    }
133
134    fn deserialize_bool<V>(
135        mut self,
136        visitor: V,
137    ) -> Result<V::Value, Self::Error>
138    where
139        V: serde::de::Visitor<'de>,
140    {
141        visitor.visit_bool(Decode::decode(&mut self.de)?)
142    }
143
144    fn deserialize_i8<V>(
145        mut self,
146        visitor: V,
147    ) -> Result<V::Value, Self::Error>
148    where
149        V: serde::de::Visitor<'de>,
150    {
151        visitor.visit_i8(Decode::decode(&mut self.de)?)
152    }
153
154    fn deserialize_i16<V>(
155        mut self,
156        visitor: V,
157    ) -> Result<V::Value, Self::Error>
158    where
159        V: serde::de::Visitor<'de>,
160    {
161        visitor.visit_i16(Decode::decode(&mut self.de)?)
162    }
163
164    fn deserialize_i32<V>(
165        mut self,
166        visitor: V,
167    ) -> Result<V::Value, Self::Error>
168    where
169        V: serde::de::Visitor<'de>,
170    {
171        visitor.visit_i32(Decode::decode(&mut self.de)?)
172    }
173
174    fn deserialize_i64<V>(
175        mut self,
176        visitor: V,
177    ) -> Result<V::Value, Self::Error>
178    where
179        V: serde::de::Visitor<'de>,
180    {
181        visitor.visit_i64(Decode::decode(&mut self.de)?)
182    }
183
184    fn deserialize_u8<V>(
185        mut self,
186        visitor: V,
187    ) -> Result<V::Value, Self::Error>
188    where
189        V: serde::de::Visitor<'de>,
190    {
191        visitor.visit_u8(Decode::decode(&mut self.de)?)
192    }
193
194    fn deserialize_u16<V>(
195        mut self,
196        visitor: V,
197    ) -> Result<V::Value, Self::Error>
198    where
199        V: serde::de::Visitor<'de>,
200    {
201        visitor.visit_u16(Decode::decode(&mut self.de)?)
202    }
203
204    fn deserialize_u32<V>(
205        mut self,
206        visitor: V,
207    ) -> Result<V::Value, Self::Error>
208    where
209        V: serde::de::Visitor<'de>,
210    {
211        visitor.visit_u32(Decode::decode(&mut self.de)?)
212    }
213
214    fn deserialize_u64<V>(
215        mut self,
216        visitor: V,
217    ) -> Result<V::Value, Self::Error>
218    where
219        V: serde::de::Visitor<'de>,
220    {
221        visitor.visit_u64(Decode::decode(&mut self.de)?)
222    }
223
224    fn deserialize_f32<V>(
225        mut self,
226        visitor: V,
227    ) -> Result<V::Value, Self::Error>
228    where
229        V: serde::de::Visitor<'de>,
230    {
231        visitor.visit_f32(Decode::decode(&mut self.de)?)
232    }
233
234    fn deserialize_f64<V>(
235        mut self,
236        visitor: V,
237    ) -> Result<V::Value, Self::Error>
238    where
239        V: serde::de::Visitor<'de>,
240    {
241        visitor.visit_f64(Decode::decode(&mut self.de)?)
242    }
243
244    fn deserialize_char<V>(
245        mut self,
246        visitor: V,
247    ) -> Result<V::Value, Self::Error>
248    where
249        V: serde::de::Visitor<'de>,
250    {
251        visitor.visit_char(Decode::decode(&mut self.de)?)
252    }
253
254    fn deserialize_str<V>(
255        mut self,
256        visitor: V,
257    ) -> Result<V::Value, Self::Error>
258    where
259        V: serde::de::Visitor<'de>,
260    {
261        let str = <&'de str>::borrow_decode(&mut self.de)?;
262        visitor.visit_borrowed_str(str)
263    }
264
265    #[cfg(not(feature = "alloc"))]
266    fn deserialize_string<V>(
267        self,
268        _: V,
269    ) -> Result<V::Value, Self::Error>
270    where
271        V: serde::de::Visitor<'de>,
272    {
273        return super::cold_decode_error_cannot_borrow_owned_data::<'de, V>().map_err(|e| e.into());
274    }
275
276    #[cfg(feature = "alloc")]
277    fn deserialize_string<V>(
278        mut self,
279        visitor: V,
280    ) -> Result<V::Value, Self::Error>
281    where
282        V: serde::de::Visitor<'de>,
283    {
284        visitor.visit_string(Decode::decode(&mut self.de)?)
285    }
286
287    fn deserialize_bytes<V>(
288        mut self,
289        visitor: V,
290    ) -> Result<V::Value, Self::Error>
291    where
292        V: serde::de::Visitor<'de>,
293    {
294        let bytes = <&'de [u8]>::borrow_decode(&mut self.de)?;
295        visitor.visit_borrowed_bytes(bytes)
296    }
297
298    #[cfg(not(feature = "alloc"))]
299    fn deserialize_byte_buf<V>(
300        self,
301        _: V,
302    ) -> Result<V::Value, Self::Error>
303    where
304        V: serde::de::Visitor<'de>,
305    {
306        return super::cold_decode_error_cannot_borrow_owned_data::<'de, V>().map_err(|e| e.into());
307    }
308
309    #[cfg(feature = "alloc")]
310    fn deserialize_byte_buf<V>(
311        mut self,
312        visitor: V,
313    ) -> Result<V::Value, Self::Error>
314    where
315        V: serde::de::Visitor<'de>,
316    {
317        visitor.visit_byte_buf(Decode::decode(&mut self.de)?)
318    }
319
320    fn deserialize_option<V>(
321        mut self,
322        visitor: V,
323    ) -> Result<V::Value, Self::Error>
324    where
325        V: serde::de::Visitor<'de>,
326    {
327        let variant = crate::de::decode_option_variant(&mut self.de, "Option<T>")?;
328        if variant.is_some() {
329            visitor.visit_some(self)
330        } else {
331            visitor.visit_none()
332        }
333    }
334
335    fn deserialize_unit<V>(
336        self,
337        visitor: V,
338    ) -> Result<V::Value, Self::Error>
339    where
340        V: serde::de::Visitor<'de>,
341    {
342        visitor.visit_unit()
343    }
344
345    fn deserialize_unit_struct<V>(
346        self,
347        _name: &'static str,
348        visitor: V,
349    ) -> Result<V::Value, Self::Error>
350    where
351        V: serde::de::Visitor<'de>,
352    {
353        visitor.visit_unit()
354    }
355
356    fn deserialize_newtype_struct<V>(
357        self,
358        _name: &'static str,
359        visitor: V,
360    ) -> Result<V::Value, Self::Error>
361    where
362        V: serde::de::Visitor<'de>,
363    {
364        visitor.visit_newtype_struct(self)
365    }
366
367    fn deserialize_seq<V>(
368        mut self,
369        visitor: V,
370    ) -> Result<V::Value, Self::Error>
371    where
372        V: serde::de::Visitor<'de>,
373    {
374        let len = usize::decode(&mut self.de)?;
375        self.deserialize_tuple(len, visitor)
376    }
377
378    fn deserialize_tuple<V>(
379        mut self,
380        len: usize,
381        visitor: V,
382    ) -> Result<V::Value, Self::Error>
383    where
384        V: serde::de::Visitor<'de>,
385    {
386        struct Access<'a, 'b, 'de, DE: BorrowDecoder<'de>> {
387            deserializer: &'a mut SerdeDecoder<'b, 'de, DE>,
388            len: usize,
389        }
390
391        impl<'de, 'a, 'b: 'a, DE: BorrowDecoder<'de> + 'b> SeqAccess<'de> for Access<'a, 'b, 'de, DE> {
392            type Error = DecodeError;
393
394            fn next_element_seed<T>(
395                &mut self,
396                seed: T,
397            ) -> Result<Option<T::Value>, DecodeError>
398            where
399                T: DeserializeSeed<'de>,
400            {
401                if self.len > 0 {
402                    self.len -= 1;
403                    let value = match DeserializeSeed::deserialize(
404                        seed,
405                        SerdeDecoder {
406                            de: self.deserializer.de,
407                            pd: PhantomData,
408                        },
409                    ) {
410                        | Ok(v) => v,
411                        | Err(DecodeError::UnexpectedEnd { .. }) => return Ok(None),
412                        | Err(e) => return Err(e),
413                    };
414                    Ok(Some(value))
415                } else {
416                    Ok(None)
417                }
418            }
419
420            fn size_hint(&self) -> Option<usize> {
421                Some(self.len)
422            }
423        }
424
425        visitor.visit_seq(Access {
426            deserializer: &mut self,
427            len,
428        })
429    }
430
431    fn deserialize_tuple_struct<V>(
432        self,
433        _name: &'static str,
434        len: usize,
435        visitor: V,
436    ) -> Result<V::Value, Self::Error>
437    where
438        V: serde::de::Visitor<'de>,
439    {
440        self.deserialize_tuple(len, visitor)
441    }
442
443    fn deserialize_map<V>(
444        mut self,
445        visitor: V,
446    ) -> Result<V::Value, Self::Error>
447    where
448        V: serde::de::Visitor<'de>,
449    {
450        struct Access<'a, 'b, 'de, DE: BorrowDecoder<'de>> {
451            deserializer: &'a mut SerdeDecoder<'b, 'de, DE>,
452            len: usize,
453        }
454
455        impl<'de, 'a, 'b: 'a, DE: BorrowDecoder<'de> + 'b> MapAccess<'de> for Access<'a, 'b, 'de, DE> {
456            type Error = DecodeError;
457
458            fn next_key_seed<K>(
459                &mut self,
460                seed: K,
461            ) -> Result<Option<K::Value>, DecodeError>
462            where
463                K: DeserializeSeed<'de>,
464            {
465                if self.len > 0 {
466                    self.len -= 1;
467                    let key = DeserializeSeed::deserialize(
468                        seed,
469                        SerdeDecoder {
470                            de: self.deserializer.de,
471                            pd: PhantomData,
472                        },
473                    )?;
474                    Ok(Some(key))
475                } else {
476                    Ok(None)
477                }
478            }
479
480            fn next_value_seed<V>(
481                &mut self,
482                seed: V,
483            ) -> Result<V::Value, DecodeError>
484            where
485                V: DeserializeSeed<'de>,
486            {
487                let value = DeserializeSeed::deserialize(
488                    seed,
489                    SerdeDecoder {
490                        de: self.deserializer.de,
491                        pd: PhantomData,
492                    },
493                )?;
494                Ok(value)
495            }
496
497            fn size_hint(&self) -> Option<usize> {
498                Some(self.len)
499            }
500        }
501
502        let len = usize::decode(&mut self.de)?;
503
504        visitor.visit_map(Access {
505            deserializer: &mut self,
506            len,
507        })
508    }
509
510    fn deserialize_struct<V>(
511        self,
512        _name: &'static str,
513        fields: &'static [&'static str],
514        visitor: V,
515    ) -> Result<V::Value, Self::Error>
516    where
517        V: serde::de::Visitor<'de>,
518    {
519        self.deserialize_tuple(fields.len(), visitor)
520    }
521
522    fn deserialize_enum<V>(
523        self,
524        _name: &'static str,
525        _variants: &'static [&'static str],
526        visitor: V,
527    ) -> Result<V::Value, Self::Error>
528    where
529        V: serde::de::Visitor<'de>,
530    {
531        visitor.visit_enum(self)
532    }
533
534    fn deserialize_identifier<V>(
535        self,
536        _visitor: V,
537    ) -> Result<V::Value, Self::Error>
538    where
539        V: serde::de::Visitor<'de>,
540    {
541        super::cold_decode_error_identifier_not_supported::<'de, V>()
542            .map_err(core::convert::Into::into)
543    }
544
545    fn deserialize_ignored_any<V>(
546        self,
547        _: V,
548    ) -> Result<V::Value, Self::Error>
549    where
550        V: serde::de::Visitor<'de>,
551    {
552        super::cold_decode_error_ignored_any_not_supported::<'de, V>()
553            .map_err(core::convert::Into::into)
554    }
555
556    fn is_human_readable(&self) -> bool {
557        false
558    }
559}
560
561impl<'de, DE: BorrowDecoder<'de>> EnumAccess<'de> for SerdeDecoder<'_, 'de, DE> {
562    type Error = DecodeError;
563    type Variant = Self;
564
565    fn variant_seed<V>(
566        mut self,
567        seed: V,
568    ) -> Result<(V::Value, Self::Variant), Self::Error>
569    where
570        V: DeserializeSeed<'de>,
571    {
572        let idx = u32::decode(&mut self.de)?;
573        let de: serde::de::value::U32Deserializer<crate::error::DecodeError> =
574            idx.into_deserializer();
575        let val = seed.deserialize(de)?;
576        Ok((val, self))
577    }
578}
579
580impl<'de, DE: BorrowDecoder<'de>> VariantAccess<'de> for SerdeDecoder<'_, 'de, DE> {
581    type Error = DecodeError;
582
583    fn unit_variant(self) -> Result<(), Self::Error> {
584        Ok(())
585    }
586
587    fn newtype_variant_seed<T>(
588        self,
589        seed: T,
590    ) -> Result<T::Value, Self::Error>
591    where
592        T: DeserializeSeed<'de>,
593    {
594        DeserializeSeed::deserialize(seed, self)
595    }
596
597    fn tuple_variant<V>(
598        self,
599        len: usize,
600        visitor: V,
601    ) -> Result<V::Value, Self::Error>
602    where
603        V: Visitor<'de>,
604    {
605        Deserializer::deserialize_tuple(self, len, visitor)
606    }
607
608    fn struct_variant<V>(
609        self,
610        fields: &'static [&'static str],
611        visitor: V,
612    ) -> Result<V::Value, Self::Error>
613    where
614        V: Visitor<'de>,
615    {
616        Deserializer::deserialize_tuple(self, fields.len(), visitor)
617    }
618}
bincode_next/features/serde/de_borrowed.rs

bincode_next/features/serde/
de_borrowed.rs
