bincode/features/serde/
de_owned.rs

1use super::{de_borrowed::borrow_decode_from_slice, DecodeError as SerdeDecodeError};
2use crate::{
3    config::Config,
4    de::{read::Reader, Decode, Decoder, DecoderImpl},
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
98pub(super) struct SerdeDecoder<'a, DE: Decoder> {
99    pub(super) de: &'a mut DE,
100}
101
102impl<'de, DE: Decoder> Deserializer<'de> for SerdeDecoder<'_, DE> {
103    type Error = DecodeError;
104
105    fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
106    where
107        V: serde::de::Visitor<'de>,
108    {
109        Err(SerdeDecodeError::AnyNotSupported.into())
110    }
111
112    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
113    where
114        V: serde::de::Visitor<'de>,
115    {
116        visitor.visit_bool(Decode::decode(&mut self.de)?)
117    }
118
119    fn deserialize_i8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
120    where
121        V: serde::de::Visitor<'de>,
122    {
123        visitor.visit_i8(Decode::decode(&mut self.de)?)
124    }
125
126    fn deserialize_i16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
127    where
128        V: serde::de::Visitor<'de>,
129    {
130        visitor.visit_i16(Decode::decode(&mut self.de)?)
131    }
132
133    fn deserialize_i32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
134    where
135        V: serde::de::Visitor<'de>,
136    {
137        visitor.visit_i32(Decode::decode(&mut self.de)?)
138    }
139
140    fn deserialize_i64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
141    where
142        V: serde::de::Visitor<'de>,
143    {
144        visitor.visit_i64(Decode::decode(&mut self.de)?)
145    }
146
147    serde::serde_if_integer128! {
148        fn deserialize_i128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
149        where
150            V: serde::de::Visitor<'de>,
151        {
152            visitor.visit_i128(Decode::decode(&mut self.de)?)
153        }
154    }
155
156    fn deserialize_u8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
157    where
158        V: serde::de::Visitor<'de>,
159    {
160        visitor.visit_u8(Decode::decode(&mut self.de)?)
161    }
162
163    fn deserialize_u16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
164    where
165        V: serde::de::Visitor<'de>,
166    {
167        visitor.visit_u16(Decode::decode(&mut self.de)?)
168    }
169
170    fn deserialize_u32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
171    where
172        V: serde::de::Visitor<'de>,
173    {
174        visitor.visit_u32(Decode::decode(&mut self.de)?)
175    }
176
177    fn deserialize_u64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
178    where
179        V: serde::de::Visitor<'de>,
180    {
181        visitor.visit_u64(Decode::decode(&mut self.de)?)
182    }
183
184    serde::serde_if_integer128! {
185        fn deserialize_u128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
186        where
187            V: serde::de::Visitor<'de>,
188        {
189            visitor.visit_u128(Decode::decode(&mut self.de)?)
190        }
191    }
192
193    fn deserialize_f32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
194    where
195        V: serde::de::Visitor<'de>,
196    {
197        visitor.visit_f32(Decode::decode(&mut self.de)?)
198    }
199
200    fn deserialize_f64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
201    where
202        V: serde::de::Visitor<'de>,
203    {
204        visitor.visit_f64(Decode::decode(&mut self.de)?)
205    }
206
207    fn deserialize_char<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
208    where
209        V: serde::de::Visitor<'de>,
210    {
211        visitor.visit_char(Decode::decode(&mut self.de)?)
212    }
213
214    #[cfg(feature = "alloc")]
215    fn deserialize_str<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
216    where
217        V: serde::de::Visitor<'de>,
218    {
219        visitor.visit_string(Decode::decode(&mut self.de)?)
220    }
221
222    #[cfg(not(feature = "alloc"))]
223    fn deserialize_str<V>(self, _: V) -> Result<V::Value, Self::Error>
224    where
225        V: serde::de::Visitor<'de>,
226    {
227        Err(SerdeDecodeError::CannotBorrowOwnedData.into())
228    }
229
230    #[cfg(feature = "alloc")]
231    fn deserialize_string<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
232    where
233        V: serde::de::Visitor<'de>,
234    {
235        visitor.visit_string(Decode::decode(&mut self.de)?)
236    }
237
238    #[cfg(not(feature = "alloc"))]
239    fn deserialize_string<V>(self, _: V) -> Result<V::Value, Self::Error>
240    where
241        V: serde::de::Visitor<'de>,
242    {
243        Err(SerdeDecodeError::CannotAllocate.into())
244    }
245
246    #[cfg(feature = "alloc")]
247    fn deserialize_bytes<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
248    where
249        V: serde::de::Visitor<'de>,
250    {
251        visitor.visit_byte_buf(Decode::decode(&mut self.de)?)
252    }
253
254    #[cfg(not(feature = "alloc"))]
255    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
256    where
257        V: serde::de::Visitor<'de>,
258    {
259        Err(SerdeDecodeError::CannotBorrowOwnedData.into())
260    }
261
262    #[cfg(feature = "alloc")]
263    fn deserialize_byte_buf<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
264    where
265        V: serde::de::Visitor<'de>,
266    {
267        visitor.visit_byte_buf(Decode::decode(&mut self.de)?)
268    }
269    #[cfg(not(feature = "alloc"))]
270    fn deserialize_byte_buf<V>(self, _: V) -> Result<V::Value, Self::Error>
271    where
272        V: serde::de::Visitor<'de>,
273    {
274        Err(SerdeDecodeError::CannotAllocate.into())
275    }
276
277    fn deserialize_option<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
278    where
279        V: serde::de::Visitor<'de>,
280    {
281        let variant = crate::de::decode_option_variant(&mut self.de, "Option<T>")?;
282        if variant.is_some() {
283            visitor.visit_some(self)
284        } else {
285            visitor.visit_none()
286        }
287    }
288
289    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
290    where
291        V: serde::de::Visitor<'de>,
292    {
293        visitor.visit_unit()
294    }
295
296    fn deserialize_unit_struct<V>(
297        self,
298        _name: &'static str,
299        visitor: V,
300    ) -> Result<V::Value, Self::Error>
301    where
302        V: serde::de::Visitor<'de>,
303    {
304        visitor.visit_unit()
305    }
306
307    fn deserialize_newtype_struct<V>(
308        self,
309        _name: &'static str,
310        visitor: V,
311    ) -> Result<V::Value, Self::Error>
312    where
313        V: serde::de::Visitor<'de>,
314    {
315        visitor.visit_newtype_struct(self)
316    }
317
318    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
319    where
320        V: serde::de::Visitor<'de>,
321    {
322        let len = usize::decode(&mut self.de)?;
323        self.deserialize_tuple(len, visitor)
324    }
325
326    fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
327    where
328        V: serde::de::Visitor<'de>,
329    {
330        struct Access<'a, 'b, DE: Decoder> {
331            deserializer: &'a mut SerdeDecoder<'b, DE>,
332            len: usize,
333        }
334
335        impl<'de, 'a, 'b: 'a, DE: Decoder + 'b> SeqAccess<'de> for Access<'a, 'b, DE> {
336            type Error = DecodeError;
337
338            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, DecodeError>
339            where
340                T: DeserializeSeed<'de>,
341            {
342                if self.len > 0 {
343                    self.len -= 1;
344                    let value = DeserializeSeed::deserialize(
345                        seed,
346                        SerdeDecoder {
347                            de: self.deserializer.de,
348                        },
349                    )?;
350                    Ok(Some(value))
351                } else {
352                    Ok(None)
353                }
354            }
355
356            fn size_hint(&self) -> Option<usize> {
357                Some(self.len)
358            }
359        }
360
361        visitor.visit_seq(Access {
362            deserializer: &mut self,
363            len,
364        })
365    }
366
367    fn deserialize_tuple_struct<V>(
368        self,
369        _name: &'static str,
370        len: usize,
371        visitor: V,
372    ) -> Result<V::Value, Self::Error>
373    where
374        V: serde::de::Visitor<'de>,
375    {
376        self.deserialize_tuple(len, visitor)
377    }
378
379    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
380    where
381        V: serde::de::Visitor<'de>,
382    {
383        struct Access<'a, 'b, DE: Decoder> {
384            deserializer: &'a mut SerdeDecoder<'b, DE>,
385            len: usize,
386        }
387
388        impl<'de, 'a, 'b: 'a, DE: Decoder + 'b> MapAccess<'de> for Access<'a, 'b, DE> {
389            type Error = DecodeError;
390
391            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, DecodeError>
392            where
393                K: DeserializeSeed<'de>,
394            {
395                if self.len > 0 {
396                    self.len -= 1;
397                    let key = DeserializeSeed::deserialize(
398                        seed,
399                        SerdeDecoder {
400                            de: self.deserializer.de,
401                        },
402                    )?;
403                    Ok(Some(key))
404                } else {
405                    Ok(None)
406                }
407            }
408
409            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, DecodeError>
410            where
411                V: DeserializeSeed<'de>,
412            {
413                let value = DeserializeSeed::deserialize(
414                    seed,
415                    SerdeDecoder {
416                        de: self.deserializer.de,
417                    },
418                )?;
419                Ok(value)
420            }
421
422            fn size_hint(&self) -> Option<usize> {
423                Some(self.len)
424            }
425        }
426
427        let len = usize::decode(&mut self.de)?;
428
429        visitor.visit_map(Access {
430            deserializer: &mut self,
431            len,
432        })
433    }
434
435    fn deserialize_struct<V>(
436        self,
437        _name: &'static str,
438        fields: &'static [&'static str],
439        visitor: V,
440    ) -> Result<V::Value, Self::Error>
441    where
442        V: serde::de::Visitor<'de>,
443    {
444        self.deserialize_tuple(fields.len(), visitor)
445    }
446
447    fn deserialize_enum<V>(
448        self,
449        _name: &'static str,
450        _variants: &'static [&'static str],
451        visitor: V,
452    ) -> Result<V::Value, Self::Error>
453    where
454        V: serde::de::Visitor<'de>,
455    {
456        visitor.visit_enum(self)
457    }
458
459    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
460    where
461        V: serde::de::Visitor<'de>,
462    {
463        Err(SerdeDecodeError::IdentifierNotSupported.into())
464    }
465
466    fn deserialize_ignored_any<V>(self, _: V) -> Result<V::Value, Self::Error>
467    where
468        V: serde::de::Visitor<'de>,
469    {
470        Err(SerdeDecodeError::IgnoredAnyNotSupported.into())
471    }
472
473    fn is_human_readable(&self) -> bool {
474        false
475    }
476}
477
478impl<'de, DE: Decoder> EnumAccess<'de> for SerdeDecoder<'_, DE> {
479    type Error = DecodeError;
480    type Variant = Self;
481
482    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
483    where
484        V: DeserializeSeed<'de>,
485    {
486        let idx = u32::decode(&mut self.de)?;
487        let val = seed.deserialize(idx.into_deserializer())?;
488        Ok((val, self))
489    }
490}
491
492impl<'de, DE: Decoder> VariantAccess<'de> for SerdeDecoder<'_, DE> {
493    type Error = DecodeError;
494
495    fn unit_variant(self) -> Result<(), Self::Error> {
496        Ok(())
497    }
498
499    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
500    where
501        T: DeserializeSeed<'de>,
502    {
503        DeserializeSeed::deserialize(seed, self)
504    }
505
506    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
507    where
508        V: Visitor<'de>,
509    {
510        Deserializer::deserialize_tuple(self, len, visitor)
511    }
512
513    fn struct_variant<V>(
514        self,
515        fields: &'static [&'static str],
516        visitor: V,
517    ) -> Result<V::Value, Self::Error>
518    where
519        V: Visitor<'de>,
520    {
521        Deserializer::deserialize_tuple(self, fields.len(), visitor)
522    }
523}
bincode/features/serde/de_owned.rs

bincode/features/serde/
de_owned.rs
