bincode_next/features/serde/
de_owned.rs

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

bincode_next/features/serde/
de_owned.rs
