bincode/features/serde/
de_owned.rs

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

bincode/features/serde/
de_owned.rs
