corepack/
de.rs

1//! The main deserializer mux.
2//
3// This Source Code Form is subject to the terms of the Mozilla Public License,
4// v. 2.0. If a copy of the MPL was not distributed with this file, You can
5// obtain one at https://mozilla.org/MPL/2.0/.
6#[cfg(feature = "alloc")]
7use alloc::vec::Vec;
8
9use std::marker::PhantomData;
10
11use std::str;
12
13use byteorder::{ByteOrder, BigEndian};
14
15use serde::Deserialize;
16
17use serde;
18
19use seq_deserializer::*;
20use ext_deserializer::*;
21use variant_deserializer::*;
22
23use defs::*;
24use error::Error;
25use read::{Read, Reference};
26
27/// The corepack Deserializer struct. Contains a closure that should produce
28/// the next slice of data of the given length
29pub struct Deserializer<'de, R: Read<'de>> {
30    read: R,
31    scratch: Vec<u8>,
32    phantom: PhantomData<&'de u8>,
33}
34
35impl<'de, R: Read<'de>> Deserializer<'de, R> {
36    /// Create a new Deserializer given an input function.
37    pub fn new(read: R) -> Deserializer<'de, R> {
38        Deserializer {
39            read: read,
40            scratch: vec![],
41            phantom: PhantomData,
42        }
43    }
44
45    #[inline]
46    fn input<'a>(&'a mut self, len: usize) -> Result<Reference<'de, 'a>, Error> {
47        let result = self.read.input(len, &mut self.scratch)?;
48        debug_assert!(result.len() == len);
49        Ok(result)
50    }
51
52    #[inline]
53    fn parse_str<'a, V>(reference: Reference<'de, 'a>, visitor: V) -> Result<V::Value, Error>
54        where V: serde::de::Visitor<'de>
55    {
56        match reference {
57            Reference::Borrowed(buf) => {
58                visitor.visit_borrowed_str(str::from_utf8(buf).map_err(|e| Into::<Error>::into(e))?)
59            }
60            Reference::Copied(buf) => {
61                visitor.visit_str(str::from_utf8(buf).map_err(|e| Into::<Error>::into(e))?)
62            }
63        }
64    }
65
66    #[inline]
67    fn parse_bytes<'a, V>(reference: Reference<'de, 'a>, visitor: V) -> Result<V::Value, Error>
68        where V: serde::de::Visitor<'de>
69    {
70        match reference {
71            Reference::Borrowed(buf) => visitor.visit_borrowed_bytes(buf),
72            Reference::Copied(buf) => visitor.visit_bytes(buf),
73        }
74    }
75
76    fn parse_as<V>(&mut self, visitor: V, ty: u8) -> Result<V::Value, Error>
77        where V: serde::de::Visitor<'de>
78    {
79        match ty {
80            v if POS_FIXINT.contains(v) => visitor.visit_u8(v),
81            v if NEG_FIXINT.contains(v) => visitor.visit_i8(read_signed(v)),
82            v if FIXMAP.contains(v) => {
83                let size = (v & !FIXMAP_MASK) as usize * 2;
84                visitor.visit_map(SeqDeserializer::new(self, size))
85            }
86            v if FIXARRAY.contains(v) => {
87                let size = (v & !FIXARRAY_MASK) as usize;
88                visitor.visit_seq(SeqDeserializer::new(self, size))
89            }
90            v if FIXSTR.contains(v) => {
91                let reference = self.input((v & !FIXSTR_MASK) as usize)?;
92
93                Deserializer::<'de, R>::parse_str(reference, visitor)
94            }
95            NIL => visitor.visit_unit(),
96            FALSE => visitor.visit_bool(false),
97            TRUE => visitor.visit_bool(true),
98            BIN8 => {
99                let size = self.input(1)?[0];
100                let reference = self.input(size as usize)?;
101
102                Deserializer::<'de, R>::parse_bytes(reference, visitor)
103            }
104            BIN16 => {
105                let size = BigEndian::read_u16(&self.input(U16_BYTES)?) as usize;
106                let reference = self.input(size)?;
107
108                Deserializer::<'de, R>::parse_bytes(reference, visitor)
109            }
110            BIN32 => {
111                let size = BigEndian::read_u32(&self.input(U32_BYTES)?) as usize;
112                let reference = self.input(size)?;
113
114                Deserializer::<'de, R>::parse_bytes(reference, visitor)
115            }
116            EXT8 => {
117                let size = self.input(1)?[0] as usize;
118
119                let ty: i8 = read_signed(self.input(1)?[0]);
120
121                let buf = self.input(size)?;
122                visitor.visit_map(ExtDeserializer::new(ty, &buf))
123            }
124            EXT16 => {
125                let size = BigEndian::read_u16(&self.input(U16_BYTES)?) as usize;
126
127                let ty: i8 = read_signed(self.input(1)?[0]);
128
129                let buf = self.input(size)?;
130                visitor.visit_map(ExtDeserializer::new(ty, &buf))
131            }
132            EXT32 => {
133                let size = BigEndian::read_u32(&self.input(U32_BYTES)?) as usize;
134
135                let ty: i8 = read_signed(self.input(1)?[0]);
136
137                let buf = self.input(size)?;
138                visitor.visit_map(ExtDeserializer::new(ty, &buf))
139            }
140            UINT8 => {
141                let buf = self.input(1)?;
142                visitor.visit_u8(buf[0])
143            }
144            UINT16 => {
145                let buf = self.input(U16_BYTES)?;
146                visitor.visit_u16(BigEndian::read_u16(&buf))
147            }
148            UINT32 => {
149                let buf = self.input(U32_BYTES)?;
150                visitor.visit_u32(BigEndian::read_u32(&buf))
151            }
152            UINT64 => {
153                let buf = self.input(U64_BYTES)?;
154                visitor.visit_u64(BigEndian::read_u64(&buf))
155            }
156            INT8 => {
157                let buf = self.input(1)?;
158                visitor.visit_i8(read_signed(buf[0]))
159            }
160            INT16 => {
161                let buf = self.input(U16_BYTES)?;
162                visitor.visit_i16(BigEndian::read_i16(&buf))
163            }
164            INT32 => {
165                let buf = self.input(U32_BYTES)?;
166                visitor.visit_i32(BigEndian::read_i32(&buf))
167            }
168            INT64 => {
169                let buf = self.input(U64_BYTES)?;
170                visitor.visit_i64(BigEndian::read_i64(&buf))
171            }
172            FLOAT32 => {
173                let buf = self.input(U32_BYTES)?;
174                visitor.visit_f32(BigEndian::read_f32(&buf))
175            }
176            FLOAT64 => {
177                let buf = self.input(U64_BYTES)?;
178                visitor.visit_f64(BigEndian::read_f64(&buf))
179            }
180            FIXEXT1 => {
181                let ty: i8 = read_signed(self.input(1)?[0]);
182
183                let buf = self.input(1)?;
184                visitor.visit_map(ExtDeserializer::new(ty, &buf))
185            }
186            FIXEXT2 => {
187                let ty: i8 = read_signed(self.input(1)?[0]);
188
189                let buf = self.input(2)?;
190                visitor.visit_map(ExtDeserializer::new(ty, &buf))
191            }
192            FIXEXT4 => {
193                let ty: i8 = read_signed(self.input(1)?[0]);
194
195                let buf = self.input(4)?;
196                visitor.visit_map(ExtDeserializer::new(ty, &buf))
197            }
198            FIXEXT8 => {
199                let ty: i8 = read_signed(self.input(1)?[0]);
200
201                let buf = self.input(8)?;
202                visitor.visit_map(ExtDeserializer::new(ty, &buf))
203            }
204            FIXEXT16 => {
205                let ty: i8 = read_signed(self.input(1)?[0]);
206
207                let buf = self.input(16)?;
208                visitor.visit_map(ExtDeserializer::new(ty, &buf))
209            }
210            STR8 => {
211                let size = self.input(1)?[0] as usize;
212
213                let buf = self.input(size)?;
214                Deserializer::<'de, R>::parse_str(buf, visitor)
215            }
216            STR16 => {
217                let size = BigEndian::read_u16(&self.input(U16_BYTES)?) as usize;
218
219                let buf = self.input(size)?;
220                Deserializer::<'de, R>::parse_str(buf, visitor)
221            }
222            STR32 => {
223                let size = BigEndian::read_u16(&self.input(U32_BYTES)?) as usize;
224
225                let buf = self.input(size)?;
226                Deserializer::<'de, R>::parse_str(buf, visitor)
227            }
228            ARRAY16 => {
229                let size = BigEndian::read_u16(&self.input(U16_BYTES)?);
230
231                visitor.visit_seq(SeqDeserializer::new(self, size as usize))
232            }
233            ARRAY32 => {
234                let size = BigEndian::read_u32(&self.input(U32_BYTES)?);
235
236                visitor.visit_seq(SeqDeserializer::new(self, size as usize))
237            }
238            MAP16 => {
239                let size = BigEndian::read_u16(&self.input(U16_BYTES)?);
240
241                visitor.visit_map(SeqDeserializer::new(self, size as usize * 2))
242            }
243            MAP32 => {
244                let size = BigEndian::read_u32(&self.input(U32_BYTES)?);
245
246                visitor.visit_map(SeqDeserializer::new(self, size as usize * 2))
247            }
248            _ => Err(Error::BadType),
249        }
250    }
251}
252
253impl<'de, 'a, R: Read<'de>> serde::Deserializer<'de> for &'a mut Deserializer<'de, R> {
254    type Error = Error;
255
256    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
257        where V: serde::de::Visitor<'de>
258    {
259        let ty = self.input(1)?[0];
260
261        self.parse_as(visitor, ty)
262    }
263
264    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
265        where V: serde::de::Visitor<'de>
266    {
267        self.deserialize_any(visitor)
268    }
269
270    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>
271        where V: serde::de::Visitor<'de>
272    {
273        self.deserialize_any(visitor)
274    }
275
276    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>
277        where V: serde::de::Visitor<'de>
278    {
279        self.deserialize_u64(visitor)
280    }
281
282    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>
283        where V: serde::de::Visitor<'de>
284    {
285        self.deserialize_u64(visitor)
286    }
287
288    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>
289        where V: serde::de::Visitor<'de>
290    {
291        self.deserialize_u64(visitor)
292    }
293
294    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>
295        where V: serde::de::Visitor<'de>
296    {
297        self.deserialize_any(visitor)
298    }
299
300    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>
301        where V: serde::de::Visitor<'de>
302    {
303        self.deserialize_i64(visitor)
304    }
305
306    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>
307        where V: serde::de::Visitor<'de>
308    {
309        self.deserialize_i64(visitor)
310    }
311
312    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>
313        where V: serde::de::Visitor<'de>
314    {
315        self.deserialize_i64(visitor)
316    }
317
318    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>
319        where V: serde::de::Visitor<'de>
320    {
321        self.deserialize_any(visitor)
322    }
323
324    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>
325        where V: serde::de::Visitor<'de>
326    {
327        self.deserialize_f64(visitor)
328    }
329
330    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
331        where V: serde::de::Visitor<'de>
332    {
333        self.deserialize_any(visitor)
334    }
335
336    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
337        where V: serde::de::Visitor<'de>
338    {
339        self.deserialize_str(visitor)
340    }
341
342    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
343        where V: serde::de::Visitor<'de>
344    {
345        self.deserialize_str(visitor)
346    }
347
348    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
349        where V: serde::de::Visitor<'de>
350    {
351        self.deserialize_any(visitor)
352    }
353
354    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
355        where V: serde::de::Visitor<'de>
356    {
357        // hack below
358        let (is_some /* maybe value */,) = Deserialize::deserialize(&mut *self)?;
359
360        if is_some {
361            // This works because there are no terminating sequences for tuples or the like
362            visitor.visit_some(self)
363            // otherwise cleanup would be required here
364        } else {
365            visitor.visit_none()
366        }
367    }
368
369    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
370        where V: serde::de::Visitor<'de>
371    {
372        self.deserialize_any(visitor)
373    }
374
375    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
376        where V: serde::de::Visitor<'de>
377    {
378        self.deserialize_any(visitor)
379    }
380
381    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
382        where V: serde::de::Visitor<'de>
383    {
384        self.deserialize_any(visitor)
385    }
386
387    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
388        where V: serde::de::Visitor<'de>
389    {
390        self.deserialize_any(visitor)
391    }
392
393    fn deserialize_unit_struct<V>(self, _: &'static str, visitor: V) -> Result<V::Value, Error>
394        where V: serde::de::Visitor<'de>
395    {
396        self.deserialize_unit(visitor)
397    }
398
399    fn deserialize_newtype_struct<V>(self, _: &'static str, visitor: V) -> Result<V::Value, Error>
400        where V: serde::de::Visitor<'de>
401    {
402        self.deserialize_any(visitor)
403    }
404
405    fn deserialize_tuple_struct<V>(self,
406                                   _: &'static str,
407                                   len: usize,
408                                   visitor: V)
409                                   -> Result<V::Value, Error>
410        where V: serde::de::Visitor<'de>
411    {
412        self.deserialize_tuple(len, visitor)
413    }
414
415    fn deserialize_struct<V>(self,
416                             _: &'static str,
417                             _: &'static [&'static str],
418                             visitor: V)
419                             -> Result<V::Value, Error>
420        where V: serde::de::Visitor<'de>
421    {
422        self.deserialize_map(visitor)
423    }
424
425    fn deserialize_tuple<V>(self, _: usize, visitor: V) -> Result<V::Value, Error>
426        where V: serde::de::Visitor<'de>
427    {
428        self.deserialize_seq(visitor)
429    }
430
431    fn deserialize_enum<V>(self,
432                           _: &'static str,
433                           variants: &'static [&'static str],
434                           visitor: V)
435                           -> Result<V::Value, Error>
436        where V: serde::de::Visitor<'de>
437    {
438        visitor.visit_enum(VariantDeserializer::new(self, variants))
439    }
440
441    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
442        where V: serde::de::Visitor<'de>
443    {
444        self.deserialize_any(visitor)
445    }
446
447    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
448        where V: serde::de::Visitor<'de>
449    {
450        self.deserialize_any(visitor)
451    }
452}
453
454#[cfg(test)]
455mod test {
456    use std::collections::BTreeMap;
457
458    #[test]
459    fn positive_fixint_test() {
460        let value: u8 = ::from_bytes(&[0x17]).unwrap();
461        assert_eq!(value, 23);
462    }
463
464    #[test]
465    fn negative_fixint_test() {
466        let value: i8 = ::from_bytes(&[0xfb]).unwrap();
467        assert_eq!(value, -5);
468    }
469
470    #[test]
471    fn uint8_test() {
472        let value: u8 = ::from_bytes(&[0xcc, 0x9a]).unwrap();
473        assert_eq!(value, 154);
474    }
475
476    #[test]
477    fn f64_test() {
478        let value: f64 = ::from_bytes(&[0xcb, 0x40, 0x59, 0, 0, 0, 0, 0, 0]).unwrap();
479        assert_eq!(value, 100.0);
480    }
481
482    #[test]
483    fn fixstr_test() {
484        let value: String = ::from_bytes(&[0xac, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f,
485                                           0x72, 0x6c, 0x64, 0x21])
486            .unwrap();
487        assert_eq!(value, "Hello World!");
488    }
489
490    #[test]
491    fn str8_test() {
492        let s: &str = "The quick brown fox jumps over the lazy dog";
493        let mut fixture: Vec<u8> = vec![];
494        fixture.push(0xd9);
495        fixture.push(s.len() as u8);
496        fixture.extend_from_slice(s.as_bytes());
497        let value: String = ::from_bytes(fixture.as_slice()).unwrap();
498        assert_eq!(value, s);
499    }
500
501    #[test]
502    fn fixarr_test() {
503        let v: Vec<u8> = ::from_bytes(&[0x94, 0x05, 0x08, 0x14, 0xcc, 0xe7]).unwrap();
504        assert_eq!(v, &[5, 8, 20, 231]);
505    }
506
507    #[test]
508    fn array16_test() {
509        let v: Vec<isize> = ::from_bytes(&[0xdc, 0x00, 0x11, 0xfb, 0x10, 0x65, 0xd0, 0xd3, 0xcc,
510                                           0xb8, 0x59, 0x3e, 0xd1, 0xff, 0x17, 0xd0, 0xdf, 0xd1,
511                                           0x01, 0x30, 0x4c, 0x5a, 0x17, 0x6c, 0x2d, 0xfd, 0x02])
512            .unwrap();
513
514        assert_eq!(v,
515                   &[-5, 16, 101, -45, 184, 89, 62, -233, -33, 304, 76, 90, 23, 108, 45, -3, 2]);
516    }
517
518    #[test]
519    fn fixmap_test() {
520        let mut map: BTreeMap<String, usize> = ::from_bytes(&[0x83, 0xa3, 0x6f, 0x6e, 0x65, 0x01,
521                                                              0xa5, 0x74, 0x68, 0x72, 0x65, 0x65,
522                                                              0x03, 0xa3, 0x74, 0x77, 0x6f, 0x02])
523            .unwrap();
524        assert_eq!(map.remove(&format!("one")), Some(1));
525        assert_eq!(map.remove(&format!("two")), Some(2));
526        assert_eq!(map.remove(&format!("three")), Some(3));
527        assert!(map.is_empty());
528    }
529}
corepack/de.rs

corepack/
de.rs
