oxicode/de/
impls.rs

1//! Decode implementations for primitive and standard types
2
3use super::{read::Reader, Decode, Decoder};
4use crate::{
5    config::{Endianness, IntEncoding, InternalEndianConfig, InternalIntEncodingConfig},
6    error::Error,
7};
8use core::marker::PhantomData;
9
10// ===== Unit and PhantomData =====
11
12impl Decode for () {
13    fn decode<D: Decoder<Context = ()>>(_: &mut D) -> Result<Self, Error> {
14        Ok(())
15    }
16}
17
18impl<T: ?Sized> Decode for PhantomData<T> {
19    fn decode<D: Decoder<Context = ()>>(_: &mut D) -> Result<Self, Error> {
20        Ok(PhantomData)
21    }
22}
23
24impl<'__de, T: ?Sized> crate::de::BorrowDecode<'__de> for PhantomData<T> {
25    fn borrow_decode<D: crate::de::BorrowDecoder<'__de, Context = ()>>(
26        _decoder: &mut D,
27    ) -> Result<Self, crate::error::Error> {
28        Ok(PhantomData)
29    }
30}
31
32// ===== Boolean =====
33
34impl Decode for bool {
35    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
36        match u8::decode(decoder)? {
37            0 => Ok(false),
38            1 => Ok(true),
39            v => Err(Error::InvalidBooleanValue(v)),
40        }
41    }
42}
43
44// ===== Unsigned Integers =====
45
46impl Decode for u8 {
47    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
48        let mut bytes = [0u8; 1];
49        decoder.reader().read(&mut bytes)?;
50        Ok(bytes[0])
51    }
52}
53
54impl Decode for u16 {
55    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
56        match D::C::INT_ENCODING {
57            IntEncoding::Variable => {
58                crate::varint::varint_decode_u16(decoder.reader(), D::C::ENDIAN)
59            }
60            IntEncoding::Fixed => {
61                let mut bytes = [0u8; 2];
62                decoder.reader().read(&mut bytes)?;
63                Ok(match D::C::ENDIAN {
64                    Endianness::Big => u16::from_be_bytes(bytes),
65                    Endianness::Little => u16::from_le_bytes(bytes),
66                })
67            }
68        }
69    }
70}
71
72impl Decode for u32 {
73    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
74        match D::C::INT_ENCODING {
75            IntEncoding::Variable => {
76                crate::varint::varint_decode_u32(decoder.reader(), D::C::ENDIAN)
77            }
78            IntEncoding::Fixed => {
79                let mut bytes = [0u8; 4];
80                decoder.reader().read(&mut bytes)?;
81                Ok(match D::C::ENDIAN {
82                    Endianness::Big => u32::from_be_bytes(bytes),
83                    Endianness::Little => u32::from_le_bytes(bytes),
84                })
85            }
86        }
87    }
88}
89
90impl Decode for u64 {
91    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
92        match D::C::INT_ENCODING {
93            IntEncoding::Variable => {
94                crate::varint::varint_decode_u64(decoder.reader(), D::C::ENDIAN)
95            }
96            IntEncoding::Fixed => {
97                let mut bytes = [0u8; 8];
98                decoder.reader().read(&mut bytes)?;
99                Ok(match D::C::ENDIAN {
100                    Endianness::Big => u64::from_be_bytes(bytes),
101                    Endianness::Little => u64::from_le_bytes(bytes),
102                })
103            }
104        }
105    }
106}
107
108impl Decode for u128 {
109    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
110        match D::C::INT_ENCODING {
111            IntEncoding::Variable => {
112                crate::varint::varint_decode_u128(decoder.reader(), D::C::ENDIAN)
113            }
114            IntEncoding::Fixed => {
115                let mut bytes = [0u8; 16];
116                decoder.reader().read(&mut bytes)?;
117                Ok(match D::C::ENDIAN {
118                    Endianness::Big => u128::from_be_bytes(bytes),
119                    Endianness::Little => u128::from_le_bytes(bytes),
120                })
121            }
122        }
123    }
124}
125
126impl Decode for usize {
127    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
128        match D::C::INT_ENCODING {
129            IntEncoding::Variable => {
130                crate::varint::varint_decode_usize(decoder.reader(), D::C::ENDIAN)
131            }
132            IntEncoding::Fixed => {
133                let mut bytes = [0u8; 8];
134                decoder.reader().read(&mut bytes)?;
135                let value = match D::C::ENDIAN {
136                    Endianness::Big => u64::from_be_bytes(bytes),
137                    Endianness::Little => u64::from_le_bytes(bytes),
138                };
139                Ok(value as usize)
140            }
141        }
142    }
143}
144
145// ===== Signed Integers =====
146
147impl Decode for i8 {
148    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
149        let mut bytes = [0u8; 1];
150        decoder.reader().read(&mut bytes)?;
151        Ok(bytes[0] as i8)
152    }
153}
154
155impl Decode for i16 {
156    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
157        match D::C::INT_ENCODING {
158            IntEncoding::Variable => {
159                crate::varint::varint_decode_i16(decoder.reader(), D::C::ENDIAN)
160            }
161            IntEncoding::Fixed => {
162                let mut bytes = [0u8; 2];
163                decoder.reader().read(&mut bytes)?;
164                Ok(match D::C::ENDIAN {
165                    Endianness::Big => i16::from_be_bytes(bytes),
166                    Endianness::Little => i16::from_le_bytes(bytes),
167                })
168            }
169        }
170    }
171}
172
173impl Decode for i32 {
174    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
175        match D::C::INT_ENCODING {
176            IntEncoding::Variable => {
177                crate::varint::varint_decode_i32(decoder.reader(), D::C::ENDIAN)
178            }
179            IntEncoding::Fixed => {
180                let mut bytes = [0u8; 4];
181                decoder.reader().read(&mut bytes)?;
182                Ok(match D::C::ENDIAN {
183                    Endianness::Big => i32::from_be_bytes(bytes),
184                    Endianness::Little => i32::from_le_bytes(bytes),
185                })
186            }
187        }
188    }
189}
190
191impl Decode for i64 {
192    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
193        match D::C::INT_ENCODING {
194            IntEncoding::Variable => {
195                crate::varint::varint_decode_i64(decoder.reader(), D::C::ENDIAN)
196            }
197            IntEncoding::Fixed => {
198                let mut bytes = [0u8; 8];
199                decoder.reader().read(&mut bytes)?;
200                Ok(match D::C::ENDIAN {
201                    Endianness::Big => i64::from_be_bytes(bytes),
202                    Endianness::Little => i64::from_le_bytes(bytes),
203                })
204            }
205        }
206    }
207}
208
209impl Decode for i128 {
210    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
211        match D::C::INT_ENCODING {
212            IntEncoding::Variable => {
213                crate::varint::varint_decode_i128(decoder.reader(), D::C::ENDIAN)
214            }
215            IntEncoding::Fixed => {
216                let mut bytes = [0u8; 16];
217                decoder.reader().read(&mut bytes)?;
218                Ok(match D::C::ENDIAN {
219                    Endianness::Big => i128::from_be_bytes(bytes),
220                    Endianness::Little => i128::from_le_bytes(bytes),
221                })
222            }
223        }
224    }
225}
226
227impl Decode for isize {
228    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
229        match D::C::INT_ENCODING {
230            IntEncoding::Variable => {
231                crate::varint::varint_decode_isize(decoder.reader(), D::C::ENDIAN)
232            }
233            IntEncoding::Fixed => {
234                let mut bytes = [0u8; 8];
235                decoder.reader().read(&mut bytes)?;
236                let value = match D::C::ENDIAN {
237                    Endianness::Big => i64::from_be_bytes(bytes),
238                    Endianness::Little => i64::from_le_bytes(bytes),
239                };
240                Ok(value as isize)
241            }
242        }
243    }
244}
245
246// ===== Floating Point =====
247
248impl Decode for f32 {
249    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
250        let mut bytes = [0u8; 4];
251        decoder.reader().read(&mut bytes)?;
252        Ok(match D::C::ENDIAN {
253            Endianness::Big => f32::from_be_bytes(bytes),
254            Endianness::Little => f32::from_le_bytes(bytes),
255        })
256    }
257}
258
259impl Decode for f64 {
260    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
261        let mut bytes = [0u8; 8];
262        decoder.reader().read(&mut bytes)?;
263        Ok(match D::C::ENDIAN {
264            Endianness::Big => f64::from_be_bytes(bytes),
265            Endianness::Little => f64::from_le_bytes(bytes),
266        })
267    }
268}
269
270// ===== Arrays =====
271
272impl<T: Decode, const N: usize> Decode for [T; N] {
273    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
274        // Arrays don't have length prefix (compile-time known)
275        // Use array::try_from_fn when stabilized, for now use unsafe
276        let mut result: [core::mem::MaybeUninit<T>; N] =
277            unsafe { core::mem::MaybeUninit::uninit().assume_init() };
278
279        for item in result.iter_mut() {
280            item.write(T::decode(decoder)?);
281        }
282
283        // SAFETY: All elements have been initialized
284        Ok(unsafe { core::mem::transmute_copy::<_, [T; N]>(&result) })
285    }
286}
287
288// ===== Option =====
289
290impl<T: Decode> Decode for Option<T> {
291    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
292        let variant = u8::decode(decoder)?;
293        match variant {
294            0 => Ok(None),
295            1 => Ok(Some(T::decode(decoder)?)),
296            _ => Err(Error::InvalidData {
297                message: "Invalid Option variant",
298            }),
299        }
300    }
301}
302
303// ===== Result =====
304
305impl<T: Decode, U: Decode> Decode for Result<T, U> {
306    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
307        let variant = u32::decode(decoder)?;
308        match variant {
309            0 => Ok(Ok(T::decode(decoder)?)),
310            1 => Ok(Err(U::decode(decoder)?)),
311            _ => Err(Error::InvalidData {
312                message: "Invalid Result variant",
313            }),
314        }
315    }
316}
317
318// ===== Cell & RefCell =====
319
320use core::cell::{Cell, RefCell};
321
322impl<T: Decode + Copy> Decode for Cell<T> {
323    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
324        Ok(Cell::new(T::decode(decoder)?))
325    }
326}
327
328impl<T: Decode> Decode for RefCell<T> {
329    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
330        Ok(RefCell::new(T::decode(decoder)?))
331    }
332}
333
334// ===== NonZero types =====
335
336use core::num::{
337    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
338    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
339};
340
341use crate::error::IntegerType;
342
343macro_rules! impl_decode_nonzero {
344    ($nonzero:ty, $inner:ty, $int_type:expr) => {
345        impl Decode for $nonzero {
346            fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
347                let value = <$inner>::decode(decoder)?;
348                <$nonzero>::new(value).ok_or(Error::NonZeroTypeIsZero {
349                    non_zero_type: $int_type,
350                })
351            }
352        }
353    };
354}
355
356impl_decode_nonzero!(NonZeroU8, u8, IntegerType::U8);
357impl_decode_nonzero!(NonZeroU16, u16, IntegerType::U16);
358impl_decode_nonzero!(NonZeroU32, u32, IntegerType::U32);
359impl_decode_nonzero!(NonZeroU64, u64, IntegerType::U64);
360impl_decode_nonzero!(NonZeroU128, u128, IntegerType::U128);
361impl_decode_nonzero!(NonZeroUsize, usize, IntegerType::Usize);
362impl_decode_nonzero!(NonZeroI8, i8, IntegerType::I8);
363impl_decode_nonzero!(NonZeroI16, i16, IntegerType::I16);
364impl_decode_nonzero!(NonZeroI32, i32, IntegerType::I32);
365impl_decode_nonzero!(NonZeroI64, i64, IntegerType::I64);
366impl_decode_nonzero!(NonZeroI128, i128, IntegerType::I128);
367impl_decode_nonzero!(NonZeroIsize, isize, IntegerType::Isize);
368
369// ===== Ordering =====
370
371impl Decode for core::cmp::Ordering {
372    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
373        match i8::decode(decoder)? {
374            -1 => Ok(core::cmp::Ordering::Less),
375            0 => Ok(core::cmp::Ordering::Equal),
376            1 => Ok(core::cmp::Ordering::Greater),
377            other => Err(Error::UnexpectedVariant {
378                type_name: "Ordering",
379                found: other as u8 as u32,
380            }),
381        }
382    }
383}
384
385// ===== Infallible =====
386
387impl Decode for core::convert::Infallible {
388    fn decode<D: Decoder<Context = ()>>(_decoder: &mut D) -> Result<Self, Error> {
389        Err(Error::InvalidData {
390            message: "Infallible cannot be decoded",
391        })
392    }
393}
394
395// ===== ControlFlow =====
396
397impl<B: Decode, C: Decode> Decode for core::ops::ControlFlow<B, C> {
398    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
399        match u32::decode(decoder)? {
400            0 => Ok(core::ops::ControlFlow::Continue(C::decode(decoder)?)),
401            1 => Ok(core::ops::ControlFlow::Break(B::decode(decoder)?)),
402            other => Err(Error::UnexpectedVariant {
403                type_name: "ControlFlow",
404                found: other,
405            }),
406        }
407    }
408}
409
410// ===== Wrapping & Reverse =====
411
412use core::cmp::Reverse;
413use core::num::Wrapping;
414
415impl<T: Decode> Decode for Wrapping<T> {
416    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
417        Ok(Wrapping(T::decode(decoder)?))
418    }
419}
420
421impl<T: Decode> Decode for Reverse<T> {
422    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
423        Ok(Reverse(T::decode(decoder)?))
424    }
425}
426
427// ===== Saturating =====
428
429use core::num::Saturating;
430
431impl<T: Decode> Decode for Saturating<T> {
432    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
433        Ok(Saturating(T::decode(decoder)?))
434    }
435}
436
437// ===== Range types =====
438
439use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
440
441impl<T: Decode> Decode for Range<T> {
442    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
443        Ok(Range {
444            start: T::decode(decoder)?,
445            end: T::decode(decoder)?,
446        })
447    }
448}
449
450impl<T: Decode> Decode for RangeInclusive<T> {
451    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
452        let start = T::decode(decoder)?;
453        let end = T::decode(decoder)?;
454        Ok(RangeInclusive::new(start, end))
455    }
456}
457
458impl<T: Decode> Decode for Bound<T> {
459    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
460        let variant = u8::decode(decoder)?;
461        match variant {
462            0 => Ok(Bound::Unbounded),
463            1 => Ok(Bound::Included(T::decode(decoder)?)),
464            2 => Ok(Bound::Excluded(T::decode(decoder)?)),
465            _ => Err(Error::InvalidData {
466                message: "Invalid Bound variant",
467            }),
468        }
469    }
470}
471
472impl Decode for RangeFull {
473    fn decode<D: Decoder<Context = ()>>(_decoder: &mut D) -> Result<Self, Error> {
474        Ok(..)
475    }
476}
477
478impl<T: Decode> Decode for RangeFrom<T> {
479    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
480        let start = T::decode(decoder)?;
481        Ok(start..)
482    }
483}
484
485impl<T: Decode> Decode for RangeTo<T> {
486    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
487        let end = T::decode(decoder)?;
488        Ok(..end)
489    }
490}
491
492impl<T: Decode> Decode for RangeToInclusive<T> {
493    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
494        let end = T::decode(decoder)?;
495        Ok(..=end)
496    }
497}
498
499// ===== Character =====
500
501// UTF-8 decoding constants
502const CONT_MASK: u8 = 0b0011_1111;
503
504impl Decode for char {
505    /// Decode a char from UTF-8 (bincode compatible)
506    ///
507    /// UTF-8 encoding uses variable 1-4 bytes:
508    /// - 0xxxxxxx: 1 byte (ASCII)
509    /// - 110xxxxx 10xxxxxx: 2 bytes
510    /// - 1110xxxx 10xxxxxx 10xxxxxx: 3 bytes
511    /// - 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx: 4 bytes
512    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
513        // Read the first byte to determine the length
514        let first = u8::decode(decoder)?;
515
516        let code = if first < 0x80 {
517            // 1-byte: ASCII
518            first as u32
519        } else if first < 0xE0 {
520            // 2-byte: 110xxxxx 10xxxxxx
521            let second = u8::decode(decoder)?;
522            if !is_continuation_byte(second) {
523                return Err(Error::InvalidCharEncoding([first, second, 0, 0]));
524            }
525            ((first as u32 & 0x1F) << 6) | (second as u32 & CONT_MASK as u32)
526        } else if first < 0xF0 {
527            // 3-byte: 1110xxxx 10xxxxxx 10xxxxxx
528            let second = u8::decode(decoder)?;
529            let third = u8::decode(decoder)?;
530            if !is_continuation_byte(second) || !is_continuation_byte(third) {
531                return Err(Error::InvalidCharEncoding([first, second, third, 0]));
532            }
533            ((first as u32 & 0x0F) << 12)
534                | ((second as u32 & CONT_MASK as u32) << 6)
535                | (third as u32 & CONT_MASK as u32)
536        } else {
537            // 4-byte: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
538            let second = u8::decode(decoder)?;
539            let third = u8::decode(decoder)?;
540            let fourth = u8::decode(decoder)?;
541            if !is_continuation_byte(second)
542                || !is_continuation_byte(third)
543                || !is_continuation_byte(fourth)
544            {
545                return Err(Error::InvalidCharEncoding([first, second, third, fourth]));
546            }
547            ((first as u32 & 0x07) << 18)
548                | ((second as u32 & CONT_MASK as u32) << 12)
549                | ((third as u32 & CONT_MASK as u32) << 6)
550                | (fourth as u32 & CONT_MASK as u32)
551        };
552
553        char::from_u32(code).ok_or(Error::InvalidCharEncoding([
554            (code >> 24) as u8,
555            (code >> 16) as u8,
556            (code >> 8) as u8,
557            code as u8,
558        ]))
559    }
560}
561
562/// Check if a byte is a UTF-8 continuation byte (10xxxxxx)
563#[inline]
564const fn is_continuation_byte(byte: u8) -> bool {
565    (byte & 0b1100_0000) == 0b1000_0000
566}
567
568// ===== Duration =====
569
570impl Decode for core::time::Duration {
571    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
572        let secs = u64::decode(decoder)?;
573        let nanos = u32::decode(decoder)?;
574        if nanos >= 1_000_000_000 {
575            return Err(Error::InvalidData {
576                message: "Duration subsec_nanos out of range (must be < 1_000_000_000)",
577            });
578        }
579        Ok(core::time::Duration::new(secs, nanos))
580    }
581}
582
583// ===== SystemTime =====
584
585#[cfg(feature = "std")]
586impl Decode for std::time::SystemTime {
587    fn decode<D: Decoder<Context = ()>>(decoder: &mut D) -> Result<Self, Error> {
588        let secs = i64::decode(decoder)?;
589        let nanos = u32::decode(decoder)?;
590        if nanos >= 1_000_000_000 {
591            return Err(Error::InvalidData {
592                message: "SystemTime subsec_nanos out of range (must be < 1_000_000_000)",
593            });
594        }
595        let epoch = std::time::SystemTime::UNIX_EPOCH;
596        if secs >= 0 {
597            let dur = std::time::Duration::new(secs as u64, nanos);
598            epoch.checked_add(dur).ok_or(Error::InvalidData {
599                message: "SystemTime value overflow (too far in the future)",
600            })
601        } else {
602            // Negative secs: time is before epoch.
603            // secs is negative, so we need |secs| seconds before epoch minus nanos adjustment.
604            let abs_secs = (-(secs + 1)) as u64;
605            let remaining_nanos = if nanos == 0 {
606                0u32
607            } else {
608                1_000_000_000u32 - nanos
609            };
610            // Go back (abs_secs + 1) seconds, then forward (1_000_000_000 - nanos) nanos
611            let back = std::time::Duration::new(abs_secs + 1, 0);
612            let fwd = std::time::Duration::new(0, remaining_nanos);
613            let t = epoch.checked_sub(back).ok_or(Error::InvalidData {
614                message: "SystemTime value underflow (too far in the past)",
615            })?;
616            t.checked_add(fwd).ok_or(Error::InvalidData {
617                message: "SystemTime value overflow after nanos adjustment",
618            })
619        }
620    }
621}
622
623// ===== BorrowDecode impls for primitives (delegate to Decode) =====
624// These allow the BorrowDecode derive macro to work on structs containing
625// owned types like u32, u64, bool, f32, etc.
626
627crate::impl_borrow_decode!(());
628crate::impl_borrow_decode!(bool);
629crate::impl_borrow_decode!(u8);
630crate::impl_borrow_decode!(u16);
631crate::impl_borrow_decode!(u32);
632crate::impl_borrow_decode!(u64);
633crate::impl_borrow_decode!(u128);
634crate::impl_borrow_decode!(usize);
635crate::impl_borrow_decode!(i8);
636crate::impl_borrow_decode!(i16);
637crate::impl_borrow_decode!(i32);
638crate::impl_borrow_decode!(i64);
639crate::impl_borrow_decode!(i128);
640crate::impl_borrow_decode!(isize);
641crate::impl_borrow_decode!(f32);
642crate::impl_borrow_decode!(f64);
643crate::impl_borrow_decode!(char);
644crate::impl_borrow_decode!(core::cmp::Ordering);
645crate::impl_borrow_decode!(core::convert::Infallible);
646
647// ===== BorrowDecode impls for NonZero types =====
648
649crate::impl_borrow_decode!(NonZeroU8);
650crate::impl_borrow_decode!(NonZeroU16);
651crate::impl_borrow_decode!(NonZeroU32);
652crate::impl_borrow_decode!(NonZeroU64);
653crate::impl_borrow_decode!(NonZeroU128);
654crate::impl_borrow_decode!(NonZeroUsize);
655crate::impl_borrow_decode!(NonZeroI8);
656crate::impl_borrow_decode!(NonZeroI16);
657crate::impl_borrow_decode!(NonZeroI32);
658crate::impl_borrow_decode!(NonZeroI64);
659crate::impl_borrow_decode!(NonZeroI128);
660crate::impl_borrow_decode!(NonZeroIsize);
661
662// ===== BorrowDecode for Duration =====
663
664crate::impl_borrow_decode!(core::time::Duration);
665
666// ===== BorrowDecode for SystemTime =====
667
668#[cfg(feature = "std")]
669impl<'de> crate::de::BorrowDecode<'de> for std::time::SystemTime {
670    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
671        decoder: &mut D,
672    ) -> Result<Self, crate::error::Error> {
673        <std::time::SystemTime as crate::de::Decode>::decode(decoder)
674    }
675}
676
677// ===== BorrowDecode for Wrapping & Reverse =====
678
679impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for Wrapping<T> {
680    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
681        decoder: &mut D,
682    ) -> Result<Self, crate::error::Error> {
683        Ok(Wrapping(T::borrow_decode(decoder)?))
684    }
685}
686
687impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for Reverse<T> {
688    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
689        decoder: &mut D,
690    ) -> Result<Self, crate::error::Error> {
691        Ok(Reverse(T::borrow_decode(decoder)?))
692    }
693}
694
695// ===== BorrowDecode for Saturating =====
696
697impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for Saturating<T> {
698    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
699        decoder: &mut D,
700    ) -> Result<Self, crate::error::Error> {
701        Ok(Saturating(T::borrow_decode(decoder)?))
702    }
703}
704
705// ===== BorrowDecode for Range types =====
706
707impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for core::ops::Range<T> {
708    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
709        decoder: &mut D,
710    ) -> Result<Self, crate::error::Error> {
711        Ok(core::ops::Range {
712            start: T::borrow_decode(decoder)?,
713            end: T::borrow_decode(decoder)?,
714        })
715    }
716}
717
718impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de>
719    for core::ops::RangeInclusive<T>
720{
721    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
722        decoder: &mut D,
723    ) -> Result<Self, crate::error::Error> {
724        let start = T::borrow_decode(decoder)?;
725        let end = T::borrow_decode(decoder)?;
726        Ok(core::ops::RangeInclusive::new(start, end))
727    }
728}
729
730impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for core::ops::Bound<T> {
731    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
732        decoder: &mut D,
733    ) -> Result<Self, crate::error::Error> {
734        let variant = u8::decode(decoder)?;
735        match variant {
736            0 => Ok(core::ops::Bound::Unbounded),
737            1 => Ok(core::ops::Bound::Included(T::borrow_decode(decoder)?)),
738            2 => Ok(core::ops::Bound::Excluded(T::borrow_decode(decoder)?)),
739            _ => Err(crate::error::Error::InvalidData {
740                message: "Invalid Bound variant",
741            }),
742        }
743    }
744}
745
746impl<'de> crate::de::BorrowDecode<'de> for RangeFull {
747    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
748        decoder: &mut D,
749    ) -> Result<Self, crate::error::Error> {
750        Decode::decode(decoder)
751    }
752}
753
754impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for RangeFrom<T> {
755    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
756        decoder: &mut D,
757    ) -> Result<Self, crate::error::Error> {
758        let start = T::borrow_decode(decoder)?;
759        Ok(start..)
760    }
761}
762
763impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for RangeTo<T> {
764    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
765        decoder: &mut D,
766    ) -> Result<Self, crate::error::Error> {
767        let end = T::borrow_decode(decoder)?;
768        Ok(..end)
769    }
770}
771
772impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for RangeToInclusive<T> {
773    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
774        decoder: &mut D,
775    ) -> Result<Self, crate::error::Error> {
776        let end = T::borrow_decode(decoder)?;
777        Ok(..=end)
778    }
779}
780
781// ===== BorrowDecode for Cell & RefCell =====
782
783impl<'de, T: crate::de::BorrowDecode<'de> + Copy> crate::de::BorrowDecode<'de>
784    for core::cell::Cell<T>
785{
786    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
787        decoder: &mut D,
788    ) -> Result<Self, crate::error::Error> {
789        Ok(core::cell::Cell::new(T::borrow_decode(decoder)?))
790    }
791}
792
793impl<'de, T: crate::de::BorrowDecode<'de>> crate::de::BorrowDecode<'de> for core::cell::RefCell<T> {
794    fn borrow_decode<D: crate::de::BorrowDecoder<'de, Context = ()>>(
795        decoder: &mut D,
796    ) -> Result<Self, crate::error::Error> {
797        Ok(core::cell::RefCell::new(T::borrow_decode(decoder)?))
798    }
799}
800
801// ===== BorrowDecode for ControlFlow =====
802
803impl<'__de, B, C> crate::de::BorrowDecode<'__de> for core::ops::ControlFlow<B, C>
804where
805    B: crate::de::BorrowDecode<'__de>,
806    C: crate::de::BorrowDecode<'__de>,
807{
808    fn borrow_decode<D: crate::de::BorrowDecoder<'__de, Context = ()>>(
809        decoder: &mut D,
810    ) -> Result<Self, crate::error::Error> {
811        let discriminant = u32::decode(decoder)?;
812        match discriminant {
813            0 => Ok(core::ops::ControlFlow::Continue(C::borrow_decode(decoder)?)),
814            1 => Ok(core::ops::ControlFlow::Break(B::borrow_decode(decoder)?)),
815            other => Err(crate::error::Error::UnexpectedVariant {
816                type_name: "ControlFlow",
817                found: other,
818            }),
819        }
820    }
821}
oxicode/de/impls.rs

oxicode/de/
impls.rs
