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

cu_bincode/features/serde/
de_owned.rs
