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
144#[cfg(test)]
145mod tests {
146    use crate::decode::Decode;
147
148    #[test]
149    fn decode_u8_fix_pos_int() {
150        // FixPosInt
151        let buf: &[u8] = &[0x00];
152        let mut r = crate::io::SliceReader::new(buf);
153        let decoded = u8::decode(&mut r).unwrap();
154        let expect = u8::MIN;
155        assert_eq!(decoded, expect);
156        assert_eq!(r.rest().len(), 0);
157
158        let buf: &[u8] = &[0x7f];
159        let mut r = crate::io::SliceReader::new(buf);
160        let decoded = u8::decode(&mut r).unwrap();
161        let expect = 0x7f;
162        assert_eq!(decoded, expect);
163        assert_eq!(r.rest().len(), 0);
164    }
165
166    #[test]
167    fn decode_u8() {
168        // Uint8
169        let buf: &[u8] = &[0xcc, 0x00];
170        let mut r = crate::io::SliceReader::new(buf);
171        let decoded = u8::decode(&mut r).unwrap();
172        let expect = u8::MIN;
173        assert_eq!(decoded, expect);
174        assert_eq!(r.rest().len(), 0);
175
176        let buf: &[u8] = &[0xcc, 0xff];
177        let mut r = crate::io::SliceReader::new(buf);
178        let decoded = u8::decode(&mut r).unwrap();
179        let expect = u8::MAX;
180        assert_eq!(decoded, expect);
181        assert_eq!(r.rest().len(), 0);
182    }
183
184    #[test]
185    fn decode_u16() {
186        // Uint16
187        let buf: &[u8] = &[0xcd, 0x00, 0x00];
188        let mut r = crate::io::SliceReader::new(buf);
189        let decoded = u16::decode(&mut r).unwrap();
190        let expect = u16::MIN;
191        assert_eq!(decoded, expect);
192        assert_eq!(r.rest().len(), 0);
193
194        let buf: &[u8] = &[0xcd, 0x12, 0x34];
195        let mut r = crate::io::SliceReader::new(buf);
196        let decoded = u16::decode(&mut r).unwrap();
197        let expect = 0x1234;
198        assert_eq!(decoded, expect);
199        assert_eq!(r.rest().len(), 0);
200
201        let buf: &[u8] = &[0xcd, 0xff, 0xff];
202        let mut r = crate::io::SliceReader::new(buf);
203        let decoded = u16::decode(&mut r).unwrap();
204        let expect = u16::MAX;
205        assert_eq!(decoded, expect);
206        assert_eq!(r.rest().len(), 0);
207    }
208
209    #[test]
210    fn decode_u32() {
211        // Uint32
212        let buf: &[u8] = &[0xce, 0x00, 0x00, 0x00, 0x00];
213        let mut r = crate::io::SliceReader::new(buf);
214        let decoded = u32::decode(&mut r).unwrap();
215        let expect = u32::MIN;
216        assert_eq!(decoded, expect);
217        assert_eq!(r.rest().len(), 0);
218
219        let buf: &[u8] = &[0xce, 0x12, 0x34, 0x56, 0x78];
220        let mut r = crate::io::SliceReader::new(buf);
221        let decoded = u32::decode(&mut r).unwrap();
222        let expect = 0x12345678;
223        assert_eq!(decoded, expect);
224        assert_eq!(r.rest().len(), 0);
225
226        let buf: &[u8] = &[0xce, 0xff, 0xff, 0xff, 0xff];
227        let mut r = crate::io::SliceReader::new(buf);
228        let decoded = u32::decode(&mut r).unwrap();
229        let expect = u32::MAX;
230        assert_eq!(decoded, expect);
231        assert_eq!(r.rest().len(), 0);
232    }
233
234    #[test]
235    fn decode_u64() {
236        // Uint64
237        let buf: &[u8] = &[0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
238        let mut r = crate::io::SliceReader::new(buf);
239        let decoded = u64::decode(&mut r).unwrap();
240        let expect = u64::MIN;
241        assert_eq!(decoded, expect);
242        assert_eq!(r.rest().len(), 0);
243
244        let buf: &[u8] = &[0xcf, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78];
245        let mut r = crate::io::SliceReader::new(buf);
246        let decoded = u64::decode(&mut r).unwrap();
247        let expect = 0x1234567812345678;
248        assert_eq!(decoded, expect);
249        assert_eq!(r.rest().len(), 0);
250
251        let buf: &[u8] = &[0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
252        let mut r = crate::io::SliceReader::new(buf);
253        let decoded = u64::decode(&mut r).unwrap();
254        let expect = u64::MAX;
255        assert_eq!(decoded, expect);
256        assert_eq!(r.rest().len(), 0);
257    }
258
259    #[test]
260    fn decode_i8_fix_neg_int() {
261        // FixNegInt
262        let buf: &[u8] = &[0xff];
263        let mut r = crate::io::SliceReader::new(buf);
264        let decoded = i8::decode(&mut r).unwrap();
265        let expect = -1;
266        assert_eq!(decoded, expect);
267        assert_eq!(r.rest().len(), 0);
268
269        let buf: &[u8] = &[0xe0];
270        let mut r = crate::io::SliceReader::new(buf);
271        let decoded = i8::decode(&mut r).unwrap();
272        let expect = -32;
273        assert_eq!(decoded, expect);
274        assert_eq!(r.rest().len(), 0);
275    }
276
277    #[test]
278    fn decode_i8() {
279        // Int8
280        let buf: &[u8] = &[0xd0, 0x80];
281        let mut r = crate::io::SliceReader::new(buf);
282        let decoded = i8::decode(&mut r).unwrap();
283        let expect = i8::MIN;
284        assert_eq!(decoded, expect);
285        assert_eq!(r.rest().len(), 0);
286
287        let buf: &[u8] = &[0xd0, 0x7f];
288        let mut r = crate::io::SliceReader::new(buf);
289        let decoded = i8::decode(&mut r).unwrap();
290        let expect = i8::MAX;
291        assert_eq!(decoded, expect);
292        assert_eq!(r.rest().len(), 0);
293    }
294
295    #[test]
296    fn decode_i16() {
297        // Int16
298        let buf: &[u8] = &[0xd1, 0x80, 0x00];
299        let mut r = crate::io::SliceReader::new(buf);
300        let decoded = i16::decode(&mut r).unwrap();
301        let expect = i16::MIN;
302        assert_eq!(decoded, expect);
303        assert_eq!(r.rest().len(), 0);
304
305        let buf: &[u8] = &[0xd1, 0x7f, 0xff];
306        let mut r = crate::io::SliceReader::new(buf);
307        let decoded = i16::decode(&mut r).unwrap();
308        let expect = i16::MAX;
309        assert_eq!(decoded, expect);
310        assert_eq!(r.rest().len(), 0);
311    }
312
313    #[test]
314    fn decode_i32() {
315        // Int16
316        let buf: &[u8] = &[0xd2, 0x80, 0x00, 0x00, 0x00];
317        let mut r = crate::io::SliceReader::new(buf);
318        let decoded = i32::decode(&mut r).unwrap();
319        let expect = i32::MIN;
320        assert_eq!(decoded, expect);
321        assert_eq!(r.rest().len(), 0);
322
323        let buf: &[u8] = &[0xd2, 0x7f, 0xff, 0xff, 0xff];
324        let mut r = crate::io::SliceReader::new(buf);
325        let decoded = i32::decode(&mut r).unwrap();
326        let expect = i32::MAX;
327        assert_eq!(decoded, expect);
328        assert_eq!(r.rest().len(), 0);
329    }
330
331    #[test]
332    fn decode_i64() {
333        // Int16
334        let buf: &[u8] = &[0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
335        let mut r = crate::io::SliceReader::new(buf);
336        let decoded = i64::decode(&mut r).unwrap();
337        let expect = i64::MIN;
338        assert_eq!(decoded, expect);
339        assert_eq!(r.rest().len(), 0);
340
341        let buf: &[u8] = &[0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff];
342        let mut r = crate::io::SliceReader::new(buf);
343        let decoded = i64::decode(&mut r).unwrap();
344        let expect = i64::MAX;
345        assert_eq!(decoded, expect);
346        assert_eq!(r.rest().len(), 0);
347    }
348}
messagepack_core/decode/int.rs

messagepack_core/decode/
int.rs
