platform_serialization/de/
impls.rs

1use crate::de::PlatformVersionedDecode;
2use crate::{impl_platform_versioned_borrow_decode, PlatformVersionedBorrowDecode};
3use bincode::de::read::Reader;
4use bincode::de::{BorrowDecoder, Decoder};
5use bincode::error::DecodeError;
6use bincode::Decode;
7use core::{
8    any::TypeId,
9    cell::{Cell, RefCell},
10    num::{
11        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
12        NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
13    },
14    ops::{Bound, Range, RangeInclusive},
15    time::Duration,
16};
17use platform_version::version::PlatformVersion;
18
19impl PlatformVersionedDecode for bool {
20    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
21        decoder: &mut D,
22        _: &PlatformVersion,
23    ) -> Result<Self, DecodeError> {
24        bincode::Decode::decode(decoder)
25    }
26}
27impl_platform_versioned_borrow_decode!(bool);
28
29impl PlatformVersionedDecode for u8 {
30    #[inline]
31    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
32        decoder: &mut D,
33        _: &PlatformVersion,
34    ) -> Result<Self, DecodeError> {
35        bincode::Decode::decode(decoder)
36    }
37}
38impl_platform_versioned_borrow_decode!(u8);
39
40impl PlatformVersionedDecode for NonZeroU8 {
41    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
42        decoder: &mut D,
43        _: &PlatformVersion,
44    ) -> Result<Self, DecodeError> {
45        bincode::Decode::decode(decoder)
46    }
47}
48impl_platform_versioned_borrow_decode!(NonZeroU8);
49
50impl PlatformVersionedDecode for u16 {
51    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
52        decoder: &mut D,
53        _: &PlatformVersion,
54    ) -> Result<Self, DecodeError> {
55        bincode::Decode::decode(decoder)
56    }
57}
58impl_platform_versioned_borrow_decode!(u16);
59
60impl PlatformVersionedDecode for NonZeroU16 {
61    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
62        decoder: &mut D,
63        _: &PlatformVersion,
64    ) -> Result<Self, DecodeError> {
65        bincode::Decode::decode(decoder)
66    }
67}
68impl_platform_versioned_borrow_decode!(NonZeroU16);
69
70impl PlatformVersionedDecode for u32 {
71    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
72        decoder: &mut D,
73        _: &PlatformVersion,
74    ) -> Result<Self, DecodeError> {
75        bincode::Decode::decode(decoder)
76    }
77}
78impl_platform_versioned_borrow_decode!(u32);
79
80impl PlatformVersionedDecode for NonZeroU32 {
81    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
82        decoder: &mut D,
83        _: &PlatformVersion,
84    ) -> Result<Self, DecodeError> {
85        bincode::Decode::decode(decoder)
86    }
87}
88impl_platform_versioned_borrow_decode!(NonZeroU32);
89
90impl PlatformVersionedDecode for u64 {
91    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
92        decoder: &mut D,
93        _: &PlatformVersion,
94    ) -> Result<Self, DecodeError> {
95        bincode::Decode::decode(decoder)
96    }
97}
98impl_platform_versioned_borrow_decode!(u64);
99
100impl PlatformVersionedDecode for NonZeroU64 {
101    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
102        decoder: &mut D,
103        _: &PlatformVersion,
104    ) -> Result<Self, DecodeError> {
105        bincode::Decode::decode(decoder)
106    }
107}
108impl_platform_versioned_borrow_decode!(NonZeroU64);
109
110impl PlatformVersionedDecode for u128 {
111    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
112        decoder: &mut D,
113        _: &PlatformVersion,
114    ) -> Result<Self, DecodeError> {
115        bincode::Decode::decode(decoder)
116    }
117}
118impl_platform_versioned_borrow_decode!(u128);
119
120impl PlatformVersionedDecode for NonZeroU128 {
121    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
122        decoder: &mut D,
123        _: &PlatformVersion,
124    ) -> Result<Self, DecodeError> {
125        bincode::Decode::decode(decoder)
126    }
127}
128impl_platform_versioned_borrow_decode!(NonZeroU128);
129
130impl PlatformVersionedDecode for usize {
131    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
132        decoder: &mut D,
133        _: &PlatformVersion,
134    ) -> Result<Self, DecodeError> {
135        bincode::Decode::decode(decoder)
136    }
137}
138impl_platform_versioned_borrow_decode!(usize);
139
140impl PlatformVersionedDecode for NonZeroUsize {
141    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
142        decoder: &mut D,
143        _: &PlatformVersion,
144    ) -> Result<Self, DecodeError> {
145        bincode::Decode::decode(decoder)
146    }
147}
148impl_platform_versioned_borrow_decode!(NonZeroUsize);
149
150impl PlatformVersionedDecode for i8 {
151    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
152        decoder: &mut D,
153        _: &PlatformVersion,
154    ) -> Result<Self, DecodeError> {
155        bincode::Decode::decode(decoder)
156    }
157}
158impl_platform_versioned_borrow_decode!(i8);
159
160impl PlatformVersionedDecode for NonZeroI8 {
161    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
162        decoder: &mut D,
163        _: &PlatformVersion,
164    ) -> Result<Self, DecodeError> {
165        bincode::Decode::decode(decoder)
166    }
167}
168impl_platform_versioned_borrow_decode!(NonZeroI8);
169
170impl PlatformVersionedDecode for i16 {
171    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
172        decoder: &mut D,
173        _: &PlatformVersion,
174    ) -> Result<Self, DecodeError> {
175        bincode::Decode::decode(decoder)
176    }
177}
178impl_platform_versioned_borrow_decode!(i16);
179
180impl PlatformVersionedDecode for NonZeroI16 {
181    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
182        decoder: &mut D,
183        _: &PlatformVersion,
184    ) -> Result<Self, DecodeError> {
185        bincode::Decode::decode(decoder)
186    }
187}
188impl_platform_versioned_borrow_decode!(NonZeroI16);
189
190impl PlatformVersionedDecode for i32 {
191    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
192        decoder: &mut D,
193        _: &PlatformVersion,
194    ) -> Result<Self, DecodeError> {
195        bincode::Decode::decode(decoder)
196    }
197}
198impl_platform_versioned_borrow_decode!(i32);
199
200impl PlatformVersionedDecode for NonZeroI32 {
201    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
202        decoder: &mut D,
203        _: &PlatformVersion,
204    ) -> Result<Self, DecodeError> {
205        bincode::Decode::decode(decoder)
206    }
207}
208impl_platform_versioned_borrow_decode!(NonZeroI32);
209
210impl PlatformVersionedDecode for i64 {
211    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
212        decoder: &mut D,
213        _: &PlatformVersion,
214    ) -> Result<Self, DecodeError> {
215        bincode::Decode::decode(decoder)
216    }
217}
218impl_platform_versioned_borrow_decode!(i64);
219
220impl PlatformVersionedDecode for NonZeroI64 {
221    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
222        decoder: &mut D,
223        _: &PlatformVersion,
224    ) -> Result<Self, DecodeError> {
225        bincode::Decode::decode(decoder)
226    }
227}
228impl_platform_versioned_borrow_decode!(NonZeroI64);
229
230impl PlatformVersionedDecode for i128 {
231    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
232        decoder: &mut D,
233        _: &PlatformVersion,
234    ) -> Result<Self, DecodeError> {
235        bincode::Decode::decode(decoder)
236    }
237}
238impl_platform_versioned_borrow_decode!(i128);
239
240impl PlatformVersionedDecode for NonZeroI128 {
241    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
242        decoder: &mut D,
243        _: &PlatformVersion,
244    ) -> Result<Self, DecodeError> {
245        bincode::Decode::decode(decoder)
246    }
247}
248impl_platform_versioned_borrow_decode!(NonZeroI128);
249
250impl PlatformVersionedDecode for isize {
251    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
252        decoder: &mut D,
253        _: &PlatformVersion,
254    ) -> Result<Self, DecodeError> {
255        bincode::Decode::decode(decoder)
256    }
257}
258impl_platform_versioned_borrow_decode!(isize);
259
260impl PlatformVersionedDecode for NonZeroIsize {
261    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
262        decoder: &mut D,
263        _: &PlatformVersion,
264    ) -> Result<Self, DecodeError> {
265        bincode::Decode::decode(decoder)
266    }
267}
268impl_platform_versioned_borrow_decode!(NonZeroIsize);
269
270impl PlatformVersionedDecode for f32 {
271    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
272        decoder: &mut D,
273        _: &PlatformVersion,
274    ) -> Result<Self, DecodeError> {
275        bincode::Decode::decode(decoder)
276    }
277}
278impl_platform_versioned_borrow_decode!(f32);
279
280impl PlatformVersionedDecode for f64 {
281    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
282        decoder: &mut D,
283        _: &PlatformVersion,
284    ) -> Result<Self, DecodeError> {
285        bincode::Decode::decode(decoder)
286    }
287}
288impl_platform_versioned_borrow_decode!(f64);
289
290impl PlatformVersionedDecode for char {
291    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
292        decoder: &mut D,
293        _: &PlatformVersion,
294    ) -> Result<Self, DecodeError> {
295        bincode::Decode::decode(decoder)
296    }
297}
298impl_platform_versioned_borrow_decode!(char);
299
300impl<'a, 'de: 'a> PlatformVersionedBorrowDecode<'de> for &'a [u8] {
301    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
302        decoder: &mut D,
303        _: &PlatformVersion,
304    ) -> Result<Self, DecodeError> {
305        bincode::BorrowDecode::borrow_decode(decoder)
306    }
307}
308
309impl<'a, 'de: 'a> PlatformVersionedBorrowDecode<'de> for &'a str {
310    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
311        decoder: &mut D,
312        _: &PlatformVersion,
313    ) -> Result<Self, DecodeError> {
314        bincode::BorrowDecode::borrow_decode(decoder)
315    }
316}
317
318impl<T, const N: usize> PlatformVersionedDecode for [T; N]
319where
320    T: PlatformVersionedDecode + Sized + 'static,
321{
322    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
323        decoder: &mut D,
324        platform_version: &PlatformVersion,
325    ) -> Result<Self, DecodeError> {
326        decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
327
328        // Optimize for `[u8; N]`
329        if TypeId::of::<u8>() == TypeId::of::<T>() {
330            let mut buf = [0u8; N];
331            decoder.reader().read(&mut buf)?;
332            let ptr = &mut buf as *mut _ as *mut [T; N];
333
334            // Safety: we know that T is a u8, so it is perfectly safe to
335            // translate an array of u8 into an array of T
336            let res = unsafe { ptr.read() };
337            Ok(res)
338        } else {
339            let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
340                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
341                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
342                T::platform_versioned_decode(decoder, platform_version)
343            }));
344
345            // result is only None if N does not match the values of `(0..N)`, which it always should
346            // So this unwrap should never occur
347            result.unwrap()
348        }
349    }
350}
351
352impl<'de, T, const N: usize> PlatformVersionedBorrowDecode<'de> for [T; N]
353where
354    T: PlatformVersionedBorrowDecode<'de> + Sized + 'static,
355{
356    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
357        decoder: &mut D,
358        platform_version: &PlatformVersion,
359    ) -> Result<Self, DecodeError> {
360        decoder.claim_bytes_read(core::mem::size_of::<[T; N]>())?;
361
362        // Optimize for `[u8; N]`
363        if TypeId::of::<u8>() == TypeId::of::<T>() {
364            let mut buf = [0u8; N];
365            decoder.reader().read(&mut buf)?;
366            let ptr = &mut buf as *mut _ as *mut [T; N];
367
368            // Safety: we know that T is a u8, so it is perfectly safe to
369            // translate an array of u8 into an array of T
370            let res = unsafe { ptr.read() };
371            Ok(res)
372        } else {
373            let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| {
374                // See the documentation on `unclaim_bytes_read` as to why we're doing this here
375                decoder.unclaim_bytes_read(core::mem::size_of::<T>());
376                T::platform_versioned_borrow_decode(decoder, platform_version)
377            }));
378
379            // result is only None if N does not match the values of `(0..N)`, which it always should
380            // So this unwrap should never occur
381            result.unwrap()
382        }
383    }
384}
385
386impl PlatformVersionedDecode for () {
387    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
388        _: &mut D,
389        _platform_version: &PlatformVersion,
390    ) -> Result<Self, DecodeError> {
391        Ok(())
392    }
393}
394impl_platform_versioned_borrow_decode!(());
395
396impl<T> PlatformVersionedDecode for core::marker::PhantomData<T> {
397    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
398        _: &mut D,
399        _platform_version: &PlatformVersion,
400    ) -> Result<Self, DecodeError> {
401        Ok(core::marker::PhantomData)
402    }
403}
404impl<'de, T> PlatformVersionedBorrowDecode<'de> for core::marker::PhantomData<T> {
405    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
406        _: &mut D,
407        _platform_version: &PlatformVersion,
408    ) -> Result<Self, DecodeError> {
409        Ok(core::marker::PhantomData)
410    }
411}
412
413impl<T> PlatformVersionedDecode for Option<T>
414where
415    T: PlatformVersionedDecode,
416{
417    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
418        decoder: &mut D,
419        platform_version: &PlatformVersion,
420    ) -> Result<Self, DecodeError> {
421        match super::decode_option_variant(decoder, core::any::type_name::<Option<T>>())? {
422            Some(_) => {
423                let val = T::platform_versioned_decode(decoder, platform_version)?;
424                Ok(Some(val))
425            }
426            None => Ok(None),
427        }
428    }
429}
430
431impl<'de, T> PlatformVersionedBorrowDecode<'de> for Option<T>
432where
433    T: PlatformVersionedBorrowDecode<'de>,
434{
435    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
436        decoder: &mut D,
437        platform_version: &PlatformVersion,
438    ) -> Result<Self, DecodeError> {
439        match super::decode_option_variant(decoder, core::any::type_name::<Option<T>>())? {
440            Some(_) => {
441                let val = T::platform_versioned_borrow_decode(decoder, platform_version)?;
442                Ok(Some(val))
443            }
444            None => Ok(None),
445        }
446    }
447}
448
449// BlockedTODO: https://github.com/rust-lang/rust/issues/37653
450//
451// We'll want to implement BorrowDecode for both Option<&[u8]> and Option<&[T: Encode]>,
452// but those implementations overlap because &'a [u8] also implements BorrowDecode
453// impl<'a, 'de: 'a> PlatformVersionedBorrowDecode<'de> for Option<&'a [u8]> {
454//     fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(decoder: &mut D, platform_version: &PlatformVersion) -> Result<Self, DecodeError> {
455//         match super::decode_option_variant(decoder, core::any::type_name::<Option<&[u8]>>())? {
456//             Some(_) => {
457//                 let val = BorrowDecode::platform_versioned_borrow_decode(decoder, platform_version)?;
458//                 Ok(Some(val))
459//             }
460//             None => Ok(None),
461//         }
462//     }
463// }
464
465impl<T, U> PlatformVersionedDecode for Result<T, U>
466where
467    T: PlatformVersionedDecode,
468    U: PlatformVersionedDecode,
469{
470    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
471        decoder: &mut D,
472        platform_version: &PlatformVersion,
473    ) -> Result<Self, DecodeError> {
474        let is_ok = u32::decode(decoder)?;
475        match is_ok {
476            0 => {
477                let t = T::platform_versioned_decode(decoder, platform_version)?;
478                Ok(Ok(t))
479            }
480            1 => {
481                let u = U::platform_versioned_decode(decoder, platform_version)?;
482                Ok(Err(u))
483            }
484            x => Err(DecodeError::UnexpectedVariant {
485                found: x,
486                allowed: &bincode::error::AllowedEnumVariants::Range { max: 1, min: 0 },
487                type_name: core::any::type_name::<Result<T, U>>(),
488            }),
489        }
490    }
491}
492
493impl<'de, T, U> PlatformVersionedBorrowDecode<'de> for Result<T, U>
494where
495    T: PlatformVersionedBorrowDecode<'de>,
496    U: PlatformVersionedBorrowDecode<'de>,
497{
498    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
499        decoder: &mut D,
500        platform_version: &PlatformVersion,
501    ) -> Result<Self, DecodeError> {
502        let is_ok = u32::decode(decoder)?;
503        match is_ok {
504            0 => {
505                let t = T::platform_versioned_borrow_decode(decoder, platform_version)?;
506                Ok(Ok(t))
507            }
508            1 => {
509                let u = U::platform_versioned_borrow_decode(decoder, platform_version)?;
510                Ok(Err(u))
511            }
512            x => Err(DecodeError::UnexpectedVariant {
513                found: x,
514                allowed: &bincode::error::AllowedEnumVariants::Range { max: 1, min: 0 },
515                type_name: core::any::type_name::<Result<T, U>>(),
516            }),
517        }
518    }
519}
520
521impl<T> PlatformVersionedDecode for Cell<T>
522where
523    T: PlatformVersionedDecode,
524{
525    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
526        decoder: &mut D,
527        platform_version: &PlatformVersion,
528    ) -> Result<Self, DecodeError> {
529        let t = T::platform_versioned_decode(decoder, platform_version)?;
530        Ok(Cell::new(t))
531    }
532}
533
534impl<'de, T> PlatformVersionedBorrowDecode<'de> for Cell<T>
535where
536    T: PlatformVersionedBorrowDecode<'de>,
537{
538    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
539        decoder: &mut D,
540        platform_version: &PlatformVersion,
541    ) -> Result<Self, DecodeError> {
542        let t = T::platform_versioned_borrow_decode(decoder, platform_version)?;
543        Ok(Cell::new(t))
544    }
545}
546
547impl<T> PlatformVersionedDecode for RefCell<T>
548where
549    T: PlatformVersionedDecode,
550{
551    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
552        decoder: &mut D,
553        platform_version: &PlatformVersion,
554    ) -> Result<Self, DecodeError> {
555        let t = T::platform_versioned_decode(decoder, platform_version)?;
556        Ok(RefCell::new(t))
557    }
558}
559
560impl<'de, T> PlatformVersionedBorrowDecode<'de> for RefCell<T>
561where
562    T: PlatformVersionedBorrowDecode<'de>,
563{
564    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
565        decoder: &mut D,
566        platform_version: &PlatformVersion,
567    ) -> Result<Self, DecodeError> {
568        let t = T::platform_versioned_borrow_decode(decoder, platform_version)?;
569        Ok(RefCell::new(t))
570    }
571}
572
573impl PlatformVersionedDecode for Duration {
574    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
575        decoder: &mut D,
576        _: &PlatformVersion,
577    ) -> Result<Self, DecodeError> {
578        bincode::Decode::decode(decoder)
579    }
580}
581impl_platform_versioned_borrow_decode!(Duration);
582
583impl<T> PlatformVersionedDecode for Range<T>
584where
585    T: PlatformVersionedDecode,
586{
587    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
588        decoder: &mut D,
589        platform_version: &PlatformVersion,
590    ) -> Result<Self, DecodeError> {
591        let min = T::platform_versioned_decode(decoder, platform_version)?;
592        let max = T::platform_versioned_decode(decoder, platform_version)?;
593        Ok(min..max)
594    }
595}
596impl<'de, T> PlatformVersionedBorrowDecode<'de> for Range<T>
597where
598    T: PlatformVersionedBorrowDecode<'de>,
599{
600    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
601        decoder: &mut D,
602        platform_version: &PlatformVersion,
603    ) -> Result<Self, DecodeError> {
604        let min = T::platform_versioned_borrow_decode(decoder, platform_version)?;
605        let max = T::platform_versioned_borrow_decode(decoder, platform_version)?;
606        Ok(min..max)
607    }
608}
609
610impl<T> PlatformVersionedDecode for RangeInclusive<T>
611where
612    T: PlatformVersionedDecode,
613{
614    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
615        decoder: &mut D,
616        platform_version: &PlatformVersion,
617    ) -> Result<Self, DecodeError> {
618        let min = T::platform_versioned_decode(decoder, platform_version)?;
619        let max = T::platform_versioned_decode(decoder, platform_version)?;
620        Ok(RangeInclusive::new(min, max))
621    }
622}
623
624impl<'de, T> PlatformVersionedBorrowDecode<'de> for RangeInclusive<T>
625where
626    T: PlatformVersionedBorrowDecode<'de>,
627{
628    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
629        decoder: &mut D,
630        platform_version: &PlatformVersion,
631    ) -> Result<Self, DecodeError> {
632        let min = T::platform_versioned_borrow_decode(decoder, platform_version)?;
633        let max = T::platform_versioned_borrow_decode(decoder, platform_version)?;
634        Ok(RangeInclusive::new(min, max))
635    }
636}
637
638impl<T> PlatformVersionedDecode for Bound<T>
639where
640    T: PlatformVersionedDecode,
641{
642    fn platform_versioned_decode<D: Decoder<Context = crate::BincodeContext>>(
643        decoder: &mut D,
644        platform_version: &PlatformVersion,
645    ) -> Result<Self, DecodeError> {
646        match u32::decode(decoder)? {
647            0 => Ok(Bound::Unbounded),
648            1 => Ok(Bound::Included(T::platform_versioned_decode(
649                decoder,
650                platform_version,
651            )?)),
652            2 => Ok(Bound::Excluded(T::platform_versioned_decode(
653                decoder,
654                platform_version,
655            )?)),
656            x => Err(DecodeError::UnexpectedVariant {
657                allowed: &bincode::error::AllowedEnumVariants::Range { max: 2, min: 0 },
658                found: x,
659                type_name: core::any::type_name::<Bound<T>>(),
660            }),
661        }
662    }
663}
664
665impl<'de, T> PlatformVersionedBorrowDecode<'de> for Bound<T>
666where
667    T: PlatformVersionedBorrowDecode<'de>,
668{
669    fn platform_versioned_borrow_decode<D: BorrowDecoder<'de, Context = crate::BincodeContext>>(
670        decoder: &mut D,
671        platform_version: &PlatformVersion,
672    ) -> Result<Self, DecodeError> {
673        match u32::decode(decoder)? {
674            0 => Ok(Bound::Unbounded),
675            1 => Ok(Bound::Included(T::platform_versioned_borrow_decode(
676                decoder,
677                platform_version,
678            )?)),
679            2 => Ok(Bound::Excluded(T::platform_versioned_borrow_decode(
680                decoder,
681                platform_version,
682            )?)),
683            x => Err(DecodeError::UnexpectedVariant {
684                allowed: &bincode::error::AllowedEnumVariants::Range { max: 2, min: 0 },
685                found: x,
686                type_name: core::any::type_name::<Bound<T>>(),
687            }),
688        }
689    }
690}
691
692#[allow(dead_code)]
693#[deprecated(note = "This function is marked as unused.")]
694#[allow(deprecated)]
695const UTF8_CHAR_WIDTH: [u8; 256] = [
696    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,
697    1, // 0x1F
698    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,
699    1, // 0x3F
700    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,
701    1, // 0x5F
702    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,
703    1, // 0x7F
704    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,
705    0, // 0x9F
706    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,
707    0, // 0xBF
708    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,
709    2, // 0xDF
710    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
711    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
712];
713
714// This function is a copy of core::str::utf8_char_width
715#[allow(dead_code)]
716#[deprecated(note = "This function is marked as unused.")]
717#[allow(deprecated)]
718const fn utf8_char_width(b: u8) -> usize {
719    UTF8_CHAR_WIDTH[b as usize] as usize
720}
platform_serialization/de/impls.rs

platform_serialization/de/
impls.rs
