bincode_next/features/serde/
de_owned.rs

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

bincode_next/features/serde/
de_owned.rs
