1use crate::error::Error;
6
7use super::{Type, Value};
8use serde::{de, Deserializer};
9
10pub struct ValueDe<'de> {
11 input: &'de Value,
12}
13pub struct ValueSeqAccess<'de> {
14 seq: &'de Vec<Value>,
15 index: usize,
16}
17pub struct ValueMapAccess<'de> {
18 seq: &'de Vec<(Value, Value)>,
19 index: usize,
20}
21pub struct ValueEnumAccess<'de> {
22 parent: &'de Value,
23 value: &'de Value,
24}
25
26impl<'de> ValueDe<'de> {
27 #[inline]
28 pub fn new(input: &'de Value) -> Self {
29 Self { input }
30 }
31}
32
33impl<'de> ValueSeqAccess<'de> {
34 #[inline]
35 fn new(seq: &'de Vec<Value>) -> Self {
36 Self { seq, index: 0 }
37 }
38}
39
40impl<'de> ValueMapAccess<'de> {
41 #[inline]
42 fn new(seq: &'de Vec<(Value, Value)>) -> Self {
43 Self { seq, index: 0 }
44 }
45}
46
47impl<'de> ValueEnumAccess<'de> {
48 #[inline]
49 fn new(parent: &'de Value, value: &'de Value) -> Self {
50 Self { parent, value }
51 }
52}
53
54impl<'de> ValueDe<'de> {
55 fn next_i8(&self) -> Result<i8, Error> {
56 match self.input {
57 Value::Long(v) => Ok(i8::try_from(*v)?),
58 Value::Int(v) => Ok(i8::try_from(*v)?),
59 Value::Short(v) => Ok(i8::try_from(*v)?),
60 Value::Char(v) => Ok(*v),
61 _ => Err(Error::Expected(Type::Char)),
62 }
63 }
64
65 fn next_i16(&self) -> Result<i16, Error> {
66 match self.input {
67 Value::Long(v) => Ok(i16::try_from(*v)?),
68 Value::Int(v) => Ok(i16::try_from(*v)?),
69 Value::Short(v) => Ok(*v),
70 Value::Char(v) => Ok(*v as i16),
71 _ => Err(Error::Expected(Type::Short)),
72 }
73 }
74
75 fn next_i32(&self) -> Result<i32, Error> {
76 match self.input {
77 Value::Long(v) => Ok(i32::try_from(*v)?),
78 Value::Int(v) => Ok(*v),
79 Value::Short(v) => Ok(*v as i32),
80 Value::Char(v) => Ok(*v as i32),
81 _ => Err(Error::Expected(Type::Int)),
82 }
83 }
84
85 fn next_i64(&self) -> Result<i64, Error> {
86 match self.input {
87 Value::Long(v) => Ok(*v),
88 Value::Int(v) => Ok(*v as i64),
89 Value::Short(v) => Ok(*v as i64),
90 Value::Char(v) => Ok(*v as i64),
91 _ => Err(Error::Expected(Type::Long)),
92 }
93 }
94
95 fn next_u8(&self) -> Result<u8, Error> {
96 match self.input {
97 Value::Long(v) => Ok(u8::try_from(*v as u64)?),
98 Value::Int(v) => Ok(u8::try_from(*v as u32)?),
99 Value::Short(v) => Ok(u8::try_from(*v as u16)?),
100 Value::Char(v) => Ok(*v as u8),
101 _ => Err(Error::Expected(Type::Char)),
102 }
103 }
104
105 fn next_u16(&self) -> Result<u16, Error> {
106 match self.input {
107 Value::Long(v) => Ok(u16::try_from(*v as u64)?),
108 Value::Int(v) => Ok(u16::try_from(*v as u32)?),
109 Value::Short(v) => Ok(*v as u16),
110 Value::Char(v) => Ok(*v as u16),
111 _ => Err(Error::Expected(Type::Short)),
112 }
113 }
114
115 fn next_u32(&self) -> Result<u32, Error> {
116 match self.input {
117 Value::Long(v) => Ok(u32::try_from(*v as u64)?),
118 Value::Int(v) => Ok(*v as u32),
119 Value::Short(v) => Ok((*v as u16) as u32),
120 Value::Char(v) => Ok((*v as u8) as u32),
121 _ => Err(Error::Expected(Type::Int)),
122 }
123 }
124
125 fn next_u64(&self) -> Result<u64, Error> {
126 match self.input {
127 Value::Long(v) => Ok(*v as u64),
128 Value::Int(v) => Ok((*v as u32) as u64),
129 Value::Short(v) => Ok((*v as u16) as u64),
130 Value::Char(v) => Ok((*v as u8) as u64),
131 _ => Err(Error::Expected(Type::Long)),
132 }
133 }
134
135 fn next_f32(&self) -> Result<f32, Error> {
136 match self.input {
137 Value::Double(v) => Ok(*v as f32),
138 Value::Float(v) => Ok(*v),
139 _ => Err(Error::Expected(Type::Float)),
140 }
141 }
142
143 fn next_f64(&self) -> Result<f64, Error> {
144 match self.input {
145 Value::Double(v) => Ok(*v),
146 Value::Float(v) => Ok(*v as f64),
147 _ => Err(Error::Expected(Type::Float)),
148 }
149 }
150
151 fn next_bytes(&self) -> Result<&Vec<u8>, Error> {
152 match self.input {
153 Value::Bytes(v) => Ok(v),
154 Value::Object(v) => Ok(v),
155 _ => Err(Error::Expected(Type::Bytes)),
156 }
157 }
158
159 fn next_str(&self) -> Result<&str, Error> {
160 match self.input {
161 Value::Str(v) => Ok(v),
162 _ => Err(Error::Expected(Type::Str)),
163 }
164 }
165}
166
167impl<'de> de::Deserializer<'de> for ValueDe<'de> {
168 type Error = Error;
169
170 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
171 where
172 V: de::Visitor<'de>,
173 {
174 match self.input {
175 Value::Long(v) => visitor.visit_i64(*v),
176 Value::Int(v) => visitor.visit_i32(*v),
177 Value::Short(v) => visitor.visit_i16(*v),
178 Value::Char(v) => visitor.visit_i8(*v),
179 Value::Float(v) => visitor.visit_f32(*v),
180 Value::Double(v) => visitor.visit_f64(*v),
181 Value::Bytes(v) => visitor.visit_bytes(v),
182 Value::Str(v) => visitor.visit_str(v),
183 Value::Object(v) => visitor.visit_bytes(v),
184 Value::Enum(_, v) => visitor.visit_enum(ValueEnumAccess::new(self.input, v)),
185 Value::Null => visitor.visit_unit(),
186 Value::List(v) => visitor.visit_seq(ValueSeqAccess::new(v)),
187 Value::Map(v) => visitor.visit_map(ValueMapAccess::new(v)),
188 }
189 }
190
191 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
192 where
193 V: de::Visitor<'de>,
194 {
195 visitor.visit_bool(self.next_i64()? != 0)
196 }
197
198 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
199 where
200 V: de::Visitor<'de>,
201 {
202 visitor.visit_i8(self.next_i8()?)
203 }
204
205 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
206 where
207 V: de::Visitor<'de>,
208 {
209 visitor.visit_i16(self.next_i16()?)
210 }
211
212 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
213 where
214 V: de::Visitor<'de>,
215 {
216 visitor.visit_i32(self.next_i32()?)
217 }
218
219 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
220 where
221 V: de::Visitor<'de>,
222 {
223 visitor.visit_i64(self.next_i64()?)
224 }
225
226 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
227 where
228 V: de::Visitor<'de>,
229 {
230 visitor.visit_u8(self.next_u8()?)
231 }
232
233 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
234 where
235 V: de::Visitor<'de>,
236 {
237 visitor.visit_u16(self.next_u16()?)
238 }
239
240 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
241 where
242 V: de::Visitor<'de>,
243 {
244 visitor.visit_u32(self.next_u32()?)
245 }
246
247 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
248 where
249 V: de::Visitor<'de>,
250 {
251 visitor.visit_u64(self.next_u64()?)
252 }
253
254 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
255 where
256 V: de::Visitor<'de>,
257 {
258 visitor.visit_f32(self.next_f32()?)
259 }
260
261 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
262 where
263 V: de::Visitor<'de>,
264 {
265 visitor.visit_f64(self.next_f64()?)
266 }
267
268 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
269 where
270 V: de::Visitor<'de>,
271 {
272 let c = match self.input {
273 Value::Char(v) => (*v as u8) as char,
274 _ => char::from_u32(self.next_u32()?)
275 .ok_or(Error::data_error("Invalid UTF-8 Character"))?,
276 };
277 visitor.visit_char(c)
278 }
279
280 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
281 where
282 V: de::Visitor<'de>,
283 {
284 visitor.visit_str(self.next_str()?)
285 }
286
287 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
288 where
289 V: de::Visitor<'de>,
290 {
291 visitor.visit_string(self.next_str()?.to_owned())
292 }
293
294 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
295 where
296 V: de::Visitor<'de>,
297 {
298 visitor.visit_bytes(self.next_bytes()?)
299 }
300
301 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
302 where
303 V: de::Visitor<'de>,
304 {
305 visitor.visit_byte_buf(self.next_bytes()?.to_owned())
306 }
307
308 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
309 where
310 V: de::Visitor<'de>,
311 {
312 if let Value::Null = self.input {
313 visitor.visit_none()
314 } else {
315 visitor.visit_some(self)
316 }
317 }
318
319 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
320 where
321 V: de::Visitor<'de>,
322 {
323 if let Value::Null = self.input {
324 visitor.visit_unit()
325 } else {
326 Err(Error::Expected(Type::Null))
327 }
328 }
329
330 fn deserialize_unit_struct<V>(
331 self,
332 _name: &'static str,
333 visitor: V,
334 ) -> Result<V::Value, Self::Error>
335 where
336 V: de::Visitor<'de>,
337 {
338 self.deserialize_unit(visitor)
339 }
340
341 fn deserialize_newtype_struct<V>(
342 self,
343 _name: &'static str,
344 visitor: V,
345 ) -> Result<V::Value, Self::Error>
346 where
347 V: de::Visitor<'de>,
348 {
349 visitor.visit_newtype_struct(self)
350 }
351
352 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
353 where
354 V: de::Visitor<'de>,
355 {
356 if let Value::List(v) = self.input {
357 visitor.visit_seq(ValueSeqAccess::new(v))
358 } else {
359 Err(Error::Expected(Type::List))
360 }
361 }
362
363 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
364 where
365 V: de::Visitor<'de>,
366 {
367 self.deserialize_seq(visitor)
368 }
369
370 fn deserialize_tuple_struct<V>(
371 self,
372 _name: &'static str,
373 _len: usize,
374 visitor: V,
375 ) -> Result<V::Value, Self::Error>
376 where
377 V: de::Visitor<'de>,
378 {
379 self.deserialize_seq(visitor)
380 }
381
382 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
383 where
384 V: de::Visitor<'de>,
385 {
386 if let Value::Map(v) = self.input {
387 visitor.visit_map(ValueMapAccess::new(v))
388 } else {
389 Err(Error::Expected(Type::Map))
390 }
391 }
392
393 fn deserialize_struct<V>(
394 self,
395 _name: &'static str,
396 _fields: &'static [&'static str],
397 visitor: V,
398 ) -> Result<V::Value, Self::Error>
399 where
400 V: de::Visitor<'de>,
401 {
402 self.deserialize_map(visitor)
403 }
404
405 fn deserialize_enum<V>(
406 self,
407 _name: &'static str,
408 _variants: &'static [&'static str],
409 visitor: V,
410 ) -> Result<V::Value, Self::Error>
411 where
412 V: de::Visitor<'de>,
413 {
414 if let Value::Enum(_, v) = self.input {
415 visitor.visit_enum(ValueEnumAccess::new(self.input, v))
416 } else {
417 Err(Error::Expected(Type::Enum))
418 }
419 }
420
421 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
422 where
423 V: de::Visitor<'de>,
424 {
425 match self.input {
426 Value::Str(v) => visitor.visit_str(v),
427 Value::Enum(variant, _) => visitor.visit_u32(*variant),
428 _ => Err(Error::Expected(Type::Str)),
429 }
430 }
431
432 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
433 where
434 V: de::Visitor<'de>,
435 {
436 visitor.visit_unit()
437 }
438}
439
440impl<'de> de::SeqAccess<'de> for ValueSeqAccess<'de> {
441 type Error = Error;
442
443 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
444 where
445 T: de::DeserializeSeed<'de>,
446 {
447 Ok(if let Some(value) = self.seq.get(self.index) {
448 self.index += 1;
449 Some(seed.deserialize(ValueDe::new(value))?)
450 } else {
451 None
452 })
453 }
454}
455
456impl<'de> de::MapAccess<'de> for ValueMapAccess<'de> {
457 type Error = Error;
458
459 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
460 where
461 K: de::DeserializeSeed<'de>,
462 {
463 Ok(if let Some((key, _value)) = self.seq.get(self.index) {
464 Some(seed.deserialize(ValueDe::new(key))?)
465 } else {
466 None
467 })
468 }
469
470 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
471 where
472 V: de::DeserializeSeed<'de>,
473 {
474 if let Some((_key, value)) = self.seq.get(self.index) {
475 self.index += 1;
476 Ok(seed.deserialize(ValueDe::new(value))?)
477 } else {
478 Err(Error::Msg("Expected index to be in bounds".into()))
479 }
480 }
481}
482
483impl<'de> de::EnumAccess<'de> for ValueEnumAccess<'de> {
484 type Error = Error;
485 type Variant = Self;
486
487 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
488 where
489 V: de::DeserializeSeed<'de>,
490 {
491 let variant = seed.deserialize(ValueDe::new(self.parent))?;
492 Ok((variant, self))
493 }
494}
495
496impl<'de> de::VariantAccess<'de> for ValueEnumAccess<'de> {
497 type Error = Error;
498
499 fn unit_variant(self) -> Result<(), Self::Error> {
500 Ok(())
501 }
502
503 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
504 where
505 T: de::DeserializeSeed<'de>,
506 {
507 seed.deserialize(ValueDe::new(self.value))
508 }
509
510 fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
511 where
512 V: de::Visitor<'de>,
513 {
514 let de = ValueDe::new(self.value);
515 de.deserialize_seq(visitor)
516 }
517
518 fn struct_variant<V>(
519 self,
520 _fields: &'static [&'static str],
521 visitor: V,
522 ) -> Result<V::Value, Self::Error>
523 where
524 V: de::Visitor<'de>,
525 {
526 let de = ValueDe::new(self.value);
527 de.deserialize_map(visitor)
528 }
529}
530
531#[cfg(test)]
532mod test {
533 use serde::{Deserialize, Serialize};
534
535 use crate::{error::Error, parser::Parser};
536
537 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
538 struct Foo {
539 a: i32,
540 b: String,
541 c: bool,
542 }
543
544 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
545 enum Bar {
546 Foo,
547 Cheese(i8),
548 Hello { a: i32 },
549 }
550
551 #[test]
552 fn test_vec() {
553 let mut parser = Parser::from(b"ac\x00\x00\x00\x04\x00\x01\x02\x03");
554 let arr: Vec<u8> = parser.next().unwrap();
555 assert_eq!(arr, vec![0, 1, 2, 3]);
556 }
557
558 #[test]
559 fn test_struct() {
560 let mut parser = Parser::from(b"M\x00\x00\x00\x29s\x00\x00\x00\x01ai\x00\x00\x00\x01s\x00\x00\x00\x01bs\x00\x00\x00\x0bHello Worlds\x00\x00\x00\x01cc\x01");
561 let arr: Foo = parser.next().unwrap();
562 assert_eq!(
563 arr,
564 Foo {
565 a: 1,
566 b: "Hello World".to_owned(),
567 c: true
568 }
569 );
570 }
571
572 #[test]
573 fn test_enum() {
574 let data = b"en\x00\x00\x00\x00ec\x00\x00\x00\x01\x10eM\x00\x00\x00\x0b\x00\x00\x00\x02s\x00\x00\x00\x01ai\x00\x00\x00\x10";
575
576 let mut parser = Parser::from(data);
577
578 let foo: Bar = parser.next().unwrap();
579 assert_eq!(foo, Bar::Foo);
580
581 let cheese: Bar = parser.next().unwrap();
582 assert_eq!(cheese, Bar::Cheese(16));
583
584 let hello: Bar = parser.next().unwrap();
585 assert_eq!(hello, Bar::Hello { a: 16 });
586 }
587
588 #[test]
589 fn test_expected() {
590 let mut parser = Parser::from(b"s\x00\x00\x00\x02hi");
591
592 let err = parser.next::<i32>().expect_err("Error::Expected");
593 if let Error::Expected(_) = err {
594 } else {
595 panic!("Expected Error::Expected");
596 }
597 }
598
599 #[test]
600 fn test_int_coersion() {
601 let mut parser = Parser::from(b"c\x32");
602
603 let val: i32 = parser.next().unwrap();
604 assert_eq!(val, 0x32);
605 }
606
607 #[test]
608 fn test_bad_int_coersion() {
609 let mut parser = Parser::from(b"i\x40\x00\x00\x00");
610
611 let err = parser.next::<i16>().expect_err("TryFromIntError");
612 if let Error::DataError(_) = err {
613 } else {
614 panic!("Expected TryFromIntError");
615 }
616 }
617
618 #[test]
619 fn test_big_int_coersion() {
620 let mut parser = Parser::from(b"i\x00\x00\x00\x40");
621
622 let val: u8 = parser.next().unwrap();
623 assert_eq!(val, 0x40);
624 }
625}