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

bincode_next/features/serde/
de_owned.rs
