bincode_next/de/
impls.rs

1#![allow(unsafe_code, clippy::cast_possible_truncation)]
2use super::{
3    read::{BorrowReader, Reader},
4    BorrowDecode, BorrowDecoder, Decode, Decoder,
5};
6use crate::{
7    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
8    error::{DecodeError, IntegerType},
9    impl_borrow_decode,
10};
11use core::{
12    cell::{Cell, RefCell},
13    cmp::Reverse,
14    num::{
15        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
16        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
17    },
18    ops::{Bound, Range, RangeInclusive},
19    time::Duration,
20};
21
22impl<Context> Decode<Context> for bool {
23    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
24        match u8::decode(decoder)? {
25            0 => Ok(false),
26            1 => Ok(true),
27            x => Err(DecodeError::InvalidBooleanValue(x)),
28        }
29    }
30}
31impl_borrow_decode!(bool);
32
33impl<Context> Decode<Context> for u8 {
34    #[inline]
35    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
36        decoder.claim_bytes_read(1)?;
37        if let Some(buf) = decoder.reader().peek_read(1) {
38            let byte = buf[0];
39            decoder.reader().consume(1);
40            Ok(byte)
41        } else {
42            let mut bytes = [0u8; 1];
43            decoder.reader().read(&mut bytes)?;
44            Ok(bytes[0])
45        }
46    }
47}
48impl_borrow_decode!(u8);
49
50impl<Context> Decode<Context> for NonZeroU8 {
51    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
52        Self::new(u8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
53            non_zero_type: IntegerType::U8,
54        })
55    }
56}
57impl_borrow_decode!(NonZeroU8);
58
59impl<Context> Decode<Context> for u16 {
60    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
61        decoder.claim_bytes_read(2)?;
62        match D::C::INT_ENCODING {
63            IntEncoding::Variable => {
64                crate::varint::varint_decode_u16(decoder.reader(), D::C::ENDIAN)
65            }
66            IntEncoding::Fixed => {
67                let mut bytes = [0u8; 2];
68                decoder.reader().read(&mut bytes)?;
69                Ok(match D::C::ENDIAN {
70                    Endianness::Little => Self::from_le_bytes(bytes),
71                    Endianness::Big => Self::from_be_bytes(bytes),
72                })
73            }
74        }
75    }
76}
77impl_borrow_decode!(u16);
78
79impl<Context> Decode<Context> for NonZeroU16 {
80    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
81        Self::new(u16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
82            non_zero_type: IntegerType::U16,
83        })
84    }
85}
86impl_borrow_decode!(NonZeroU16);
87
88impl<Context> Decode<Context> for u32 {
89    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
90        decoder.claim_bytes_read(4)?;
91        match D::C::INT_ENCODING {
92            IntEncoding::Variable => {
93                crate::varint::varint_decode_u32(decoder.reader(), D::C::ENDIAN)
94            }
95            IntEncoding::Fixed => {
96                let mut bytes = [0u8; 4];
97                decoder.reader().read(&mut bytes)?;
98                Ok(match D::C::ENDIAN {
99                    Endianness::Little => Self::from_le_bytes(bytes),
100                    Endianness::Big => Self::from_be_bytes(bytes),
101                })
102            }
103        }
104    }
105}
106impl_borrow_decode!(u32);
107
108impl<Context> Decode<Context> for NonZeroU32 {
109    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
110        Self::new(u32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
111            non_zero_type: IntegerType::U32,
112        })
113    }
114}
115impl_borrow_decode!(NonZeroU32);
116
117impl<Context> Decode<Context> for u64 {
118    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
119        decoder.claim_bytes_read(8)?;
120        match D::C::INT_ENCODING {
121            IntEncoding::Variable => {
122                crate::varint::varint_decode_u64(decoder.reader(), D::C::ENDIAN)
123            }
124            IntEncoding::Fixed => {
125                let mut bytes = [0u8; 8];
126                decoder.reader().read(&mut bytes)?;
127                Ok(match D::C::ENDIAN {
128                    Endianness::Little => Self::from_le_bytes(bytes),
129                    Endianness::Big => Self::from_be_bytes(bytes),
130                })
131            }
132        }
133    }
134}
135impl_borrow_decode!(u64);
136
137impl<Context> Decode<Context> for NonZeroU64 {
138    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
139        Self::new(u64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
140            non_zero_type: IntegerType::U64,
141        })
142    }
143}
144impl_borrow_decode!(NonZeroU64);
145
146impl<Context> Decode<Context> for u128 {
147    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
148        decoder.claim_bytes_read(16)?;
149        match D::C::INT_ENCODING {
150            IntEncoding::Variable => {
151                crate::varint::varint_decode_u128(decoder.reader(), D::C::ENDIAN)
152            }
153            IntEncoding::Fixed => {
154                let mut bytes = [0u8; 16];
155                decoder.reader().read(&mut bytes)?;
156                Ok(match D::C::ENDIAN {
157                    Endianness::Little => Self::from_le_bytes(bytes),
158                    Endianness::Big => Self::from_be_bytes(bytes),
159                })
160            }
161        }
162    }
163}
164impl_borrow_decode!(u128);
165
166impl<Context> Decode<Context> for NonZeroU128 {
167    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
168        Self::new(u128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
169            non_zero_type: IntegerType::U128,
170        })
171    }
172}
173impl_borrow_decode!(NonZeroU128);
174
175impl<Context> Decode<Context> for usize {
176    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
177        decoder.claim_bytes_read(8)?;
178        match D::C::INT_ENCODING {
179            IntEncoding::Variable => {
180                crate::varint::varint_decode_usize(decoder.reader(), D::C::ENDIAN)
181            }
182            IntEncoding::Fixed => {
183                let mut bytes = [0u8; 8];
184                decoder.reader().read(&mut bytes)?;
185
186                let value = match D::C::ENDIAN {
187                    Endianness::Little => u64::from_le_bytes(bytes),
188                    Endianness::Big => u64::from_be_bytes(bytes),
189                };
190
191                value
192                    .try_into()
193                    .map_err(|_| DecodeError::OutsideUsizeRange(value))
194            }
195        }
196    }
197}
198impl_borrow_decode!(usize);
199
200impl<Context> Decode<Context> for NonZeroUsize {
201    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
202        Self::new(usize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
203            non_zero_type: IntegerType::Usize,
204        })
205    }
206}
207impl_borrow_decode!(NonZeroUsize);
208
209impl<Context> Decode<Context> for i8 {
210    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
211        decoder.claim_bytes_read(1)?;
212        let mut bytes = [0u8; 1];
213        decoder.reader().read(&mut bytes)?;
214        Ok(Self::from_ne_bytes(bytes))
215    }
216}
217impl_borrow_decode!(i8);
218
219impl<Context> Decode<Context> for NonZeroI8 {
220    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
221        Self::new(i8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
222            non_zero_type: IntegerType::I8,
223        })
224    }
225}
226impl_borrow_decode!(NonZeroI8);
227
228impl<Context> Decode<Context> for i16 {
229    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
230        decoder.claim_bytes_read(2)?;
231        match D::C::INT_ENCODING {
232            IntEncoding::Variable => {
233                crate::varint::varint_decode_i16(decoder.reader(), D::C::ENDIAN)
234            }
235            IntEncoding::Fixed => {
236                let mut bytes = [0u8; 2];
237                decoder.reader().read(&mut bytes)?;
238                Ok(match D::C::ENDIAN {
239                    Endianness::Little => Self::from_le_bytes(bytes),
240                    Endianness::Big => Self::from_be_bytes(bytes),
241                })
242            }
243        }
244    }
245}
246impl_borrow_decode!(i16);
247
248impl<Context> Decode<Context> for NonZeroI16 {
249    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
250        Self::new(i16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
251            non_zero_type: IntegerType::I16,
252        })
253    }
254}
255impl_borrow_decode!(NonZeroI16);
256
257impl<Context> Decode<Context> for i32 {
258    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
259        decoder.claim_bytes_read(4)?;
260        match D::C::INT_ENCODING {
261            IntEncoding::Variable => {
262                crate::varint::varint_decode_i32(decoder.reader(), D::C::ENDIAN)
263            }
264            IntEncoding::Fixed => {
265                let mut bytes = [0u8; 4];
266                decoder.reader().read(&mut bytes)?;
267                Ok(match D::C::ENDIAN {
268                    Endianness::Little => Self::from_le_bytes(bytes),
269                    Endianness::Big => Self::from_be_bytes(bytes),
270                })
271            }
272        }
273    }
274}
275impl_borrow_decode!(i32);
276
277impl<Context> Decode<Context> for NonZeroI32 {
278    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
279        Self::new(i32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
280            non_zero_type: IntegerType::I32,
281        })
282    }
283}
284impl_borrow_decode!(NonZeroI32);
285
286impl<Context> Decode<Context> for i64 {
287    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
288        decoder.claim_bytes_read(8)?;
289        match D::C::INT_ENCODING {
290            IntEncoding::Variable => {
291                crate::varint::varint_decode_i64(decoder.reader(), D::C::ENDIAN)
292            }
293            IntEncoding::Fixed => {
294                let mut bytes = [0u8; 8];
295                decoder.reader().read(&mut bytes)?;
296                Ok(match D::C::ENDIAN {
297                    Endianness::Little => Self::from_le_bytes(bytes),
298                    Endianness::Big => Self::from_be_bytes(bytes),
299                })
300            }
301        }
302    }
303}
304impl_borrow_decode!(i64);
305
306impl<Context> Decode<Context> for NonZeroI64 {
307    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
308        Self::new(i64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
309            non_zero_type: IntegerType::I64,
310        })
311    }
312}
313impl_borrow_decode!(NonZeroI64);
314
315impl<Context> Decode<Context> for i128 {
316    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
317        decoder.claim_bytes_read(16)?;
318        match D::C::INT_ENCODING {
319            IntEncoding::Variable => {
320                crate::varint::varint_decode_i128(decoder.reader(), D::C::ENDIAN)
321            }
322            IntEncoding::Fixed => {
323                let mut bytes = [0u8; 16];
324                decoder.reader().read(&mut bytes)?;
325                Ok(match D::C::ENDIAN {
326                    Endianness::Little => Self::from_le_bytes(bytes),
327                    Endianness::Big => Self::from_be_bytes(bytes),
328                })
329            }
330        }
331    }
332}
333impl_borrow_decode!(i128);
334
335impl<Context> Decode<Context> for NonZeroI128 {
336    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
337        Self::new(i128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
338            non_zero_type: IntegerType::I128,
339        })
340    }
341}
342impl_borrow_decode!(NonZeroI128);
343
344impl<Context> Decode<Context> for isize {
345    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
346        decoder.claim_bytes_read(8)?;
347        match D::C::INT_ENCODING {
348            IntEncoding::Variable => {
349                crate::varint::varint_decode_isize(decoder.reader(), D::C::ENDIAN)
350            }
351            IntEncoding::Fixed => {
352                let mut bytes = [0u8; 8];
353                decoder.reader().read(&mut bytes)?;
354                Ok(match D::C::ENDIAN {
355                    Endianness::Little => i64::from_le_bytes(bytes),
356                    Endianness::Big => i64::from_be_bytes(bytes),
357                } as Self)
358            }
359        }
360    }
361}
362impl_borrow_decode!(isize);
363
364impl<Context> Decode<Context> for NonZeroIsize {
365    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
366        Self::new(isize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero {
367            non_zero_type: IntegerType::Isize,
368        })
369    }
370}
371impl_borrow_decode!(NonZeroIsize);
372
373impl<Context> Decode<Context> for f32 {
374    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
375        decoder.claim_bytes_read(4)?;
376        let mut bytes = [0u8; 4];
377        decoder.reader().read(&mut bytes)?;
378        Ok(match D::C::ENDIAN {
379            Endianness::Little => Self::from_le_bytes(bytes),
380            Endianness::Big => Self::from_be_bytes(bytes),
381        })
382    }
383}
384impl_borrow_decode!(f32);
385
386impl<Context> Decode<Context> for f64 {
387    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
388        decoder.claim_bytes_read(8)?;
389        let mut bytes = [0u8; 8];
390        decoder.reader().read(&mut bytes)?;
391        Ok(match D::C::ENDIAN {
392            Endianness::Little => Self::from_le_bytes(bytes),
393            Endianness::Big => Self::from_be_bytes(bytes),
394        })
395    }
396}
397impl_borrow_decode!(f64);
398
399impl<Context, T: Decode<Context>> Decode<Context> for Wrapping<T> {
400    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
401        Ok(Self(T::decode(decoder)?))
402    }
403}
404impl<'de, Context, T: BorrowDecode<'de, Context>> BorrowDecode<'de, Context> for Wrapping<T> {
405    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
406        decoder: &mut D,
407    ) -> Result<Self, DecodeError> {
408        Ok(Self(T::borrow_decode(decoder)?))
409    }
410}
411
412impl<Context, T: Decode<Context>> Decode<Context> for Reverse<T> {
413    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
414        Ok(Self(T::decode(decoder)?))
415    }
416}
417
418impl<'de, Context, T: BorrowDecode<'de, Context>> BorrowDecode<'de, Context> for Reverse<T> {
419    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
420        decoder: &mut D,
421    ) -> Result<Self, DecodeError> {
422        Ok(Self(T::borrow_decode(decoder)?))
423    }
424}
425
426impl<Context> Decode<Context> for char {
427    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
428        let mut array = [0u8; 4];
429
430        // Look at the first byte to see how many bytes must be read
431        decoder.reader().read(&mut array[..1])?;
432
433        let width = utf8_char_width(array[0]);
434        if width == 0 {
435            return Err(DecodeError::InvalidCharEncoding(array));
436        }
437        // Normally we have to `.claim_bytes_read` before reading, however in this
438        // case the amount of bytes read from `char` can vary wildly, and it should
439        // only read up to 4 bytes too much.
440        decoder.claim_bytes_read(width)?;
441        if width == 1 {
442            return Ok(array[0] as Self);
443        }
444
445        // read the remaining pain
446        decoder.reader().read(&mut array[1..width])?;
447        let res = core::str::from_utf8(&array[..width])
448            .ok()
449            .and_then(|s| s.chars().next())
450            .ok_or(DecodeError::InvalidCharEncoding(array))?;
451        Ok(res)
452    }
453}
454impl_borrow_decode!(char);
455
456impl<'a, 'de: 'a, Context> BorrowDecode<'de, Context> for &'a [u8] {
457    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
458        decoder: &mut D,
459    ) -> Result<Self, DecodeError> {
460        let len = super::decode_slice_len(decoder)?;
461        decoder.claim_bytes_read(len)?;
462        decoder.borrow_reader().take_bytes(len)
463    }
464}
465
466impl<'a, 'de: 'a, Context> BorrowDecode<'de, Context> for &'a str {
467    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
468        decoder: &mut D,
469    ) -> Result<Self, DecodeError> {
470        let slice = <&[u8]>::borrow_decode(decoder)?;
471        core::str::from_utf8(slice).map_err(|inner| DecodeError::Utf8 { inner })
472    }
473}
474
475impl<Context, T, const N: usize> Decode<Context> for [T; N]
476where
477    T: Decode<Context>,
478{
479    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
480        decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
481
482        if unty::type_equal::<T, u8>() {
483            let mut buf = [0u8; N];
484            decoder.reader().read(&mut buf)?;
485            let ptr = (&raw mut buf).cast::<[T; N]>();
486
487            // Safety: we know that T is a u8, so it is perfectly safe to
488            // translate an array of u8 into an array of T
489            let res = unsafe { ptr.read() };
490            Ok(res)
491        } else {
492            let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
493                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
494                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
495                T::decode(decoder)
496            }));
497
498            // result is only None if N does not match the values of `(0..N)`, which it always should
499            // So this unwrap should never occur
500            result.unwrap()
501        }
502    }
503}
504
505impl<'de, T, const N: usize, Context> BorrowDecode<'de, Context> for [T; N]
506where
507    T: BorrowDecode<'de, Context>,
508{
509    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
510        decoder: &mut D,
511    ) -> Result<Self, DecodeError> {
512        decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
513
514        if unty::type_equal::<T, u8>() {
515            let mut buf = [0u8; N];
516            decoder.reader().read(&mut buf)?;
517            let ptr = (&raw mut buf).cast::<[T; N]>();
518
519            // Safety: we know that T is a u8, so it is perfectly safe to
520            // translate an array of u8 into an array of T
521            let res = unsafe { ptr.read() };
522            Ok(res)
523        } else {
524            let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
525                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
526                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
527                T::borrow_decode(decoder)
528            }));
529
530            // result is only None if N does not match the values of `(0..N)`, which it always should
531            // So this unwrap should never occur
532            result.unwrap()
533        }
534    }
535}
536
537impl<Context> Decode<Context> for () {
538    fn decode<D: Decoder<Context = Context>>(_: &mut D) -> Result<Self, DecodeError> {
539        Ok(())
540    }
541}
542impl_borrow_decode!(());
543
544impl<Context, T> Decode<Context> for core::marker::PhantomData<T> {
545    fn decode<D: Decoder<Context = Context>>(_: &mut D) -> Result<Self, DecodeError> {
546        Ok(Self)
547    }
548}
549impl_borrow_decode!(core::marker::PhantomData<T>, T);
550
551impl<Context, T> Decode<Context> for Option<T>
552where
553    T: Decode<Context>,
554{
555    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
556        match super::decode_option_variant(decoder, core::any::type_name::<Self>())? {
557            Some(()) => {
558                let val = T::decode(decoder)?;
559                Ok(Some(val))
560            }
561            None => Ok(None),
562        }
563    }
564}
565
566impl<'de, T, Context> BorrowDecode<'de, Context> for Option<T>
567where
568    T: BorrowDecode<'de, Context>,
569{
570    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
571        decoder: &mut D,
572    ) -> Result<Self, DecodeError> {
573        match super::decode_option_variant(decoder, core::any::type_name::<Self>())? {
574            Some(()) => {
575                let val = T::borrow_decode(decoder)?;
576                Ok(Some(val))
577            }
578            None => Ok(None),
579        }
580    }
581}
582
583impl<Context, T, U> Decode<Context> for Result<T, U>
584where
585    T: Decode<Context>,
586    U: Decode<Context>,
587{
588    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
589        let is_ok = u32::decode(decoder)?;
590        match is_ok {
591            0 => {
592                let t = T::decode(decoder)?;
593                Ok(Ok(t))
594            }
595            1 => {
596                let u = U::decode(decoder)?;
597                Ok(Err(u))
598            }
599            x => Err(DecodeError::UnexpectedVariant {
600                found: x,
601                allowed: &crate::error::AllowedEnumVariants::Range { max: 1, min: 0 },
602                type_name: core::any::type_name::<Self>(),
603            }),
604        }
605    }
606}
607
608impl<'de, T, U, Context> BorrowDecode<'de, Context> for Result<T, U>
609where
610    T: BorrowDecode<'de, Context>,
611    U: BorrowDecode<'de, Context>,
612{
613    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
614        decoder: &mut D,
615    ) -> Result<Self, DecodeError> {
616        let is_ok = u32::decode(decoder)?;
617        match is_ok {
618            0 => {
619                let t = T::borrow_decode(decoder)?;
620                Ok(Ok(t))
621            }
622            1 => {
623                let u = U::borrow_decode(decoder)?;
624                Ok(Err(u))
625            }
626            x => Err(DecodeError::UnexpectedVariant {
627                found: x,
628                allowed: &crate::error::AllowedEnumVariants::Range { max: 1, min: 0 },
629                type_name: core::any::type_name::<Self>(),
630            }),
631        }
632    }
633}
634
635impl<Context, T> Decode<Context> for Cell<T>
636where
637    T: Decode<Context>,
638{
639    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
640        let t = T::decode(decoder)?;
641        Ok(Self::new(t))
642    }
643}
644
645impl<'de, T, Context> BorrowDecode<'de, Context> for Cell<T>
646where
647    T: BorrowDecode<'de, Context>,
648{
649    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
650        decoder: &mut D,
651    ) -> Result<Self, DecodeError> {
652        let t = T::borrow_decode(decoder)?;
653        Ok(Self::new(t))
654    }
655}
656
657impl<Context, T> Decode<Context> for RefCell<T>
658where
659    T: Decode<Context>,
660{
661    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
662        let t = T::decode(decoder)?;
663        Ok(Self::new(t))
664    }
665}
666
667impl<'de, T, Context> BorrowDecode<'de, Context> for RefCell<T>
668where
669    T: BorrowDecode<'de, Context>,
670{
671    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
672        decoder: &mut D,
673    ) -> Result<Self, DecodeError> {
674        let t = T::borrow_decode(decoder)?;
675        Ok(Self::new(t))
676    }
677}
678
679impl<Context> Decode<Context> for Duration {
680    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
681        const NANOS_PER_SEC: u64 = 1_000_000_000;
682        let secs: u64 = Decode::decode(decoder)?;
683        let nanos: u32 = Decode::decode(decoder)?;
684        if secs.checked_add(u64::from(nanos) / NANOS_PER_SEC).is_none() {
685            return Err(DecodeError::InvalidDuration { secs, nanos });
686        }
687        Ok(Self::new(secs, nanos))
688    }
689}
690impl_borrow_decode!(Duration);
691
692impl<Context, T> Decode<Context> for Range<T>
693where
694    T: Decode<Context>,
695{
696    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
697        let min = T::decode(decoder)?;
698        let max = T::decode(decoder)?;
699        Ok(min..max)
700    }
701}
702impl<'de, T, Context> BorrowDecode<'de, Context> for Range<T>
703where
704    T: BorrowDecode<'de, Context>,
705{
706    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
707        decoder: &mut D,
708    ) -> Result<Self, DecodeError> {
709        let min = T::borrow_decode(decoder)?;
710        let max = T::borrow_decode(decoder)?;
711        Ok(min..max)
712    }
713}
714
715impl<Context, T> Decode<Context> for RangeInclusive<T>
716where
717    T: Decode<Context>,
718{
719    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
720        let min = T::decode(decoder)?;
721        let max = T::decode(decoder)?;
722        Ok(Self::new(min, max))
723    }
724}
725
726impl<'de, T, Context> BorrowDecode<'de, Context> for RangeInclusive<T>
727where
728    T: BorrowDecode<'de, Context>,
729{
730    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
731        decoder: &mut D,
732    ) -> Result<Self, DecodeError> {
733        let min = T::borrow_decode(decoder)?;
734        let max = T::borrow_decode(decoder)?;
735        Ok(Self::new(min, max))
736    }
737}
738
739impl<T, Context> Decode<Context> for Bound<T>
740where
741    T: Decode<Context>,
742{
743    fn decode<D: Decoder<Context = Context>>(decoder: &mut D) -> Result<Self, DecodeError> {
744        match u32::decode(decoder)? {
745            0 => Ok(Self::Unbounded),
746            1 => Ok(Self::Included(T::decode(decoder)?)),
747            2 => Ok(Self::Excluded(T::decode(decoder)?)),
748            x => Err(DecodeError::UnexpectedVariant {
749                allowed: &crate::error::AllowedEnumVariants::Range { max: 2, min: 0 },
750                found: x,
751                type_name: core::any::type_name::<Self>(),
752            }),
753        }
754    }
755}
756
757impl<'de, T, Context> BorrowDecode<'de, Context> for Bound<T>
758where
759    T: BorrowDecode<'de, Context>,
760{
761    fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>(
762        decoder: &mut D,
763    ) -> Result<Self, DecodeError> {
764        match u32::decode(decoder)? {
765            0 => Ok(Self::Unbounded),
766            1 => Ok(Self::Included(T::borrow_decode(decoder)?)),
767            2 => Ok(Self::Excluded(T::borrow_decode(decoder)?)),
768            x => Err(DecodeError::UnexpectedVariant {
769                allowed: &crate::error::AllowedEnumVariants::Range { max: 2, min: 0 },
770                found: x,
771                type_name: core::any::type_name::<Self>(),
772            }),
773        }
774    }
775}
776
777const UTF8_CHAR_WIDTH: [u8; 256] = [
778    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
779    1, // 0x1F
780    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
781    1, // 0x3F
782    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
783    1, // 0x5F
784    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
785    1, // 0x7F
786    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
787    0, // 0x9F
788    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
789    0, // 0xBF
790    0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
791    2, // 0xDF
792    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
793    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
794];
795
796// This function is a copy of core::str::utf8_char_width
797const fn utf8_char_width(b: u8) -> usize {
798    UTF8_CHAR_WIDTH[b as usize] as usize
799}
bincode_next/de/impls.rs

bincode_next/de/
impls.rs
