messagepack_core/decode/
int.rs

1use super::{DecodeBorrowed, Error};
2use crate::{formats::Format, io::IoRead};
3
4impl<'de> DecodeBorrowed<'de> for u8 {
5    type Value = Self;
6
7    fn decode_borrowed_with_format<R>(
8        format: Format,
9        reader: &mut R,
10    ) -> core::result::Result<Self::Value, Error<R::Error>>
11    where
12        R: IoRead<'de>,
13    {
14        match format {
15            Format::PositiveFixInt(v) => Ok(v),
16            Format::Uint8 => {
17                let b = reader.read_slice(1).map_err(Error::Io)?;
18                let v: [u8; 1] = b.as_bytes().try_into().map_err(|_| Error::UnexpectedEof)?;
19                Ok(v[0])
20            }
21            _ => Err(Error::UnexpectedFormat),
22        }
23    }
24}
25
26impl<'de> DecodeBorrowed<'de> for i8 {
27    type Value = Self;
28
29    fn decode_borrowed_with_format<R>(
30        format: Format,
31        reader: &mut R,
32    ) -> core::result::Result<Self::Value, Error<R::Error>>
33    where
34        R: IoRead<'de>,
35    {
36        match format {
37            Format::Int8 => {
38                let b = reader.read_slice(1).map_err(Error::Io)?;
39                let v: [u8; 1] = b.as_bytes().try_into().map_err(|_| Error::UnexpectedEof)?;
40                Ok(v[0] as i8)
41            }
42            Format::NegativeFixInt(v) => Ok(v),
43            _ => Err(Error::UnexpectedFormat),
44        }
45    }
46}
47
48macro_rules! impl_decode_int {
49    ($ty:ty,$format:path) => {
50        impl<'de> DecodeBorrowed<'de> for $ty {
51            type Value = Self;
52
53            fn decode_borrowed_with_format<R>(
54                format: Format,
55                reader: &mut R,
56            ) -> core::result::Result<Self::Value, Error<R::Error>>
57            where
58                R: IoRead<'de>,
59            {
60                match format {
61                    $format => {
62                        const SIZE: usize = core::mem::size_of::<$ty>();
63                        let bytes = reader.read_slice(SIZE).map_err(Error::Io)?;
64                        let slice = bytes.as_bytes();
65                        let data: [u8; SIZE] =
66                            slice.try_into().map_err(|_| Error::UnexpectedEof)?;
67                        let val = <$ty>::from_be_bytes(data);
68                        Ok(val)
69                    }
70                    _ => Err(Error::UnexpectedFormat),
71                }
72            }
73        }
74    };
75}
76
77impl_decode_int!(u16, Format::Uint16);
78impl_decode_int!(u32, Format::Uint32);
79impl_decode_int!(u64, Format::Uint64);
80impl_decode_int!(i16, Format::Int16);
81impl_decode_int!(i32, Format::Int32);
82impl_decode_int!(i64, Format::Int64);
83
84impl<'de> DecodeBorrowed<'de> for u128 {
85    type Value = Self;
86
87    fn decode_borrowed_with_format<R>(
88        format: Format,
89        reader: &mut R,
90    ) -> core::result::Result<Self::Value, Error<R::Error>>
91    where
92        R: IoRead<'de>,
93    {
94        let val = u64::decode_borrowed_with_format(format, reader)?;
95        Ok(Self::from(val))
96    }
97}
98
99impl<'de> DecodeBorrowed<'de> for i128 {
100    type Value = Self;
101
102    fn decode_borrowed_with_format<R>(
103        format: Format,
104        reader: &mut R,
105    ) -> core::result::Result<Self::Value, Error<R::Error>>
106    where
107        R: IoRead<'de>,
108    {
109        let val = i64::decode_borrowed_with_format(format, reader)?;
110        Ok(Self::from(val))
111    }
112}
113
114impl<'de> DecodeBorrowed<'de> for usize {
115    type Value = Self;
116
117    fn decode_borrowed_with_format<R>(
118        format: Format,
119        reader: &mut R,
120    ) -> core::result::Result<Self::Value, Error<R::Error>>
121    where
122        R: IoRead<'de>,
123    {
124        let val = u64::decode_borrowed_with_format(format, reader)?;
125        usize::try_from(val).map_err(|_| Error::InvalidData)
126    }
127}
128
129impl<'de> DecodeBorrowed<'de> for isize {
130    type Value = Self;
131
132    fn decode_borrowed_with_format<R>(
133        format: Format,
134        reader: &mut R,
135    ) -> core::result::Result<Self::Value, Error<R::Error>>
136    where
137        R: IoRead<'de>,
138    {
139        let val = i64::decode_borrowed_with_format(format, reader)?;
140        isize::try_from(val).map_err(|_| Error::InvalidData)
141    }
142}
143
144macro_rules! impl_nonzero_int {
145    ($ty:ty) => {
146        impl<'de> DecodeBorrowed<'de> for core::num::NonZero<$ty> {
147            type Value = Self;
148
149            fn decode_borrowed_with_format<R>(
150                format: Format,
151                reader: &mut R,
152            ) -> core::result::Result<Self::Value, Error<R::Error>>
153            where
154                R: IoRead<'de>,
155            {
156                let val = <$ty>::decode_borrowed_with_format(format, reader)?;
157                Self::new(val).ok_or(Error::InvalidData)
158            }
159        }
160    };
161}
162impl_nonzero_int!(u8);
163impl_nonzero_int!(u16);
164impl_nonzero_int!(u32);
165impl_nonzero_int!(u64);
166impl_nonzero_int!(usize);
167impl_nonzero_int!(i8);
168impl_nonzero_int!(i16);
169impl_nonzero_int!(i32);
170impl_nonzero_int!(i64);
171impl_nonzero_int!(isize);
172
173macro_rules! impl_atomic_int {
174    ($ty:ty, $base:ty, $bits:literal) => {
175        #[cfg(target_has_atomic = $bits)]
176        impl<'de> DecodeBorrowed<'de> for $ty {
177            type Value = Self;
178
179            fn decode_borrowed_with_format<R>(
180                format: Format,
181                reader: &mut R,
182            ) -> Result<Self::Value, Error<R::Error>>
183            where
184                R: IoRead<'de>,
185            {
186                let val = <$base>::decode_borrowed_with_format(format, reader)?;
187                Ok(Self::new(val))
188            }
189        }
190    };
191}
192impl_atomic_int!(core::sync::atomic::AtomicU8, u8, "8");
193impl_atomic_int!(core::sync::atomic::AtomicU16, u16, "16");
194impl_atomic_int!(core::sync::atomic::AtomicU32, u32, "32");
195impl_atomic_int!(core::sync::atomic::AtomicU64, u64, "64");
196impl_atomic_int!(core::sync::atomic::AtomicUsize, usize, "ptr");
197impl_atomic_int!(core::sync::atomic::AtomicI8, i8, "8");
198impl_atomic_int!(core::sync::atomic::AtomicI16, i16, "16");
199impl_atomic_int!(core::sync::atomic::AtomicI32, i32, "32");
200impl_atomic_int!(core::sync::atomic::AtomicI64, i64, "64");
201impl_atomic_int!(core::sync::atomic::AtomicIsize, isize, "ptr");
202
203#[cfg(test)]
204mod tests {
205    use crate::decode::Decode;
206
207    #[test]
208    fn decode_u8_fix_pos_int() {
209        // FixPosInt
210        let buf: &[u8] = &[0x00];
211        let mut r = crate::io::SliceReader::new(buf);
212        let decoded = u8::decode(&mut r).unwrap();
213        let expect = u8::MIN;
214        assert_eq!(decoded, expect);
215        assert_eq!(r.rest().len(), 0);
216
217        let buf: &[u8] = &[0x7f];
218        let mut r = crate::io::SliceReader::new(buf);
219        let decoded = u8::decode(&mut r).unwrap();
220        let expect = 0x7f;
221        assert_eq!(decoded, expect);
222        assert_eq!(r.rest().len(), 0);
223    }
224
225    #[test]
226    fn decode_u8() {
227        // Uint8
228        let buf: &[u8] = &[0xcc, 0x00];
229        let mut r = crate::io::SliceReader::new(buf);
230        let decoded = u8::decode(&mut r).unwrap();
231        let expect = u8::MIN;
232        assert_eq!(decoded, expect);
233        assert_eq!(r.rest().len(), 0);
234
235        let buf: &[u8] = &[0xcc, 0xff];
236        let mut r = crate::io::SliceReader::new(buf);
237        let decoded = u8::decode(&mut r).unwrap();
238        let expect = u8::MAX;
239        assert_eq!(decoded, expect);
240        assert_eq!(r.rest().len(), 0);
241    }
242
243    #[test]
244    fn decode_u16() {
245        // Uint16
246        let buf: &[u8] = &[0xcd, 0x00, 0x00];
247        let mut r = crate::io::SliceReader::new(buf);
248        let decoded = u16::decode(&mut r).unwrap();
249        let expect = u16::MIN;
250        assert_eq!(decoded, expect);
251        assert_eq!(r.rest().len(), 0);
252
253        let buf: &[u8] = &[0xcd, 0x12, 0x34];
254        let mut r = crate::io::SliceReader::new(buf);
255        let decoded = u16::decode(&mut r).unwrap();
256        let expect = 0x1234;
257        assert_eq!(decoded, expect);
258        assert_eq!(r.rest().len(), 0);
259
260        let buf: &[u8] = &[0xcd, 0xff, 0xff];
261        let mut r = crate::io::SliceReader::new(buf);
262        let decoded = u16::decode(&mut r).unwrap();
263        let expect = u16::MAX;
264        assert_eq!(decoded, expect);
265        assert_eq!(r.rest().len(), 0);
266    }
267
268    #[test]
269    fn decode_u32() {
270        // Uint32
271        let buf: &[u8] = &[0xce, 0x00, 0x00, 0x00, 0x00];
272        let mut r = crate::io::SliceReader::new(buf);
273        let decoded = u32::decode(&mut r).unwrap();
274        let expect = u32::MIN;
275        assert_eq!(decoded, expect);
276        assert_eq!(r.rest().len(), 0);
277
278        let buf: &[u8] = &[0xce, 0x12, 0x34, 0x56, 0x78];
279        let mut r = crate::io::SliceReader::new(buf);
280        let decoded = u32::decode(&mut r).unwrap();
281        let expect = 0x12345678;
282        assert_eq!(decoded, expect);
283        assert_eq!(r.rest().len(), 0);
284
285        let buf: &[u8] = &[0xce, 0xff, 0xff, 0xff, 0xff];
286        let mut r = crate::io::SliceReader::new(buf);
287        let decoded = u32::decode(&mut r).unwrap();
288        let expect = u32::MAX;
289        assert_eq!(decoded, expect);
290        assert_eq!(r.rest().len(), 0);
291    }
292
293    #[test]
294    fn decode_u64() {
295        // Uint64
296        let buf: &[u8] = &[0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
297        let mut r = crate::io::SliceReader::new(buf);
298        let decoded = u64::decode(&mut r).unwrap();
299        let expect = u64::MIN;
300        assert_eq!(decoded, expect);
301        assert_eq!(r.rest().len(), 0);
302
303        let buf: &[u8] = &[0xcf, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78];
304        let mut r = crate::io::SliceReader::new(buf);
305        let decoded = u64::decode(&mut r).unwrap();
306        let expect = 0x1234567812345678;
307        assert_eq!(decoded, expect);
308        assert_eq!(r.rest().len(), 0);
309
310        let buf: &[u8] = &[0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
311        let mut r = crate::io::SliceReader::new(buf);
312        let decoded = u64::decode(&mut r).unwrap();
313        let expect = u64::MAX;
314        assert_eq!(decoded, expect);
315        assert_eq!(r.rest().len(), 0);
316    }
317
318    #[test]
319    fn decode_i8_fix_neg_int() {
320        // FixNegInt
321        let buf: &[u8] = &[0xff];
322        let mut r = crate::io::SliceReader::new(buf);
323        let decoded = i8::decode(&mut r).unwrap();
324        let expect = -1;
325        assert_eq!(decoded, expect);
326        assert_eq!(r.rest().len(), 0);
327
328        let buf: &[u8] = &[0xe0];
329        let mut r = crate::io::SliceReader::new(buf);
330        let decoded = i8::decode(&mut r).unwrap();
331        let expect = -32;
332        assert_eq!(decoded, expect);
333        assert_eq!(r.rest().len(), 0);
334    }
335
336    #[test]
337    fn decode_i8() {
338        // Int8
339        let buf: &[u8] = &[0xd0, 0x80];
340        let mut r = crate::io::SliceReader::new(buf);
341        let decoded = i8::decode(&mut r).unwrap();
342        let expect = i8::MIN;
343        assert_eq!(decoded, expect);
344        assert_eq!(r.rest().len(), 0);
345
346        let buf: &[u8] = &[0xd0, 0x7f];
347        let mut r = crate::io::SliceReader::new(buf);
348        let decoded = i8::decode(&mut r).unwrap();
349        let expect = i8::MAX;
350        assert_eq!(decoded, expect);
351        assert_eq!(r.rest().len(), 0);
352    }
353
354    #[test]
355    fn decode_i16() {
356        // Int16
357        let buf: &[u8] = &[0xd1, 0x80, 0x00];
358        let mut r = crate::io::SliceReader::new(buf);
359        let decoded = i16::decode(&mut r).unwrap();
360        let expect = i16::MIN;
361        assert_eq!(decoded, expect);
362        assert_eq!(r.rest().len(), 0);
363
364        let buf: &[u8] = &[0xd1, 0x7f, 0xff];
365        let mut r = crate::io::SliceReader::new(buf);
366        let decoded = i16::decode(&mut r).unwrap();
367        let expect = i16::MAX;
368        assert_eq!(decoded, expect);
369        assert_eq!(r.rest().len(), 0);
370    }
371
372    #[test]
373    fn decode_i32() {
374        // Int16
375        let buf: &[u8] = &[0xd2, 0x80, 0x00, 0x00, 0x00];
376        let mut r = crate::io::SliceReader::new(buf);
377        let decoded = i32::decode(&mut r).unwrap();
378        let expect = i32::MIN;
379        assert_eq!(decoded, expect);
380        assert_eq!(r.rest().len(), 0);
381
382        let buf: &[u8] = &[0xd2, 0x7f, 0xff, 0xff, 0xff];
383        let mut r = crate::io::SliceReader::new(buf);
384        let decoded = i32::decode(&mut r).unwrap();
385        let expect = i32::MAX;
386        assert_eq!(decoded, expect);
387        assert_eq!(r.rest().len(), 0);
388    }
389
390    #[test]
391    fn decode_i64() {
392        // Int16
393        let buf: &[u8] = &[0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
394        let mut r = crate::io::SliceReader::new(buf);
395        let decoded = i64::decode(&mut r).unwrap();
396        let expect = i64::MIN;
397        assert_eq!(decoded, expect);
398        assert_eq!(r.rest().len(), 0);
399
400        let buf: &[u8] = &[0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
401        let mut r = crate::io::SliceReader::new(buf);
402        let decoded = i64::decode(&mut r).unwrap();
403        let expect = i64::MAX;
404        assert_eq!(decoded, expect);
405        assert_eq!(r.rest().len(), 0);
406    }
407}
messagepack_core/decode/int.rs

messagepack_core/decode/
int.rs
