1use core::{iter::Peekable, ops::Div as _, slice::Iter};
2use std::io::{Error as IoError, ErrorKind as IoErrorKind};
3
4use nebula_fbthrift_graph_v3::dependencies::common::types::Value;
5use serde::de::{
6 self,
7 value::{BorrowedBytesDeserializer, SeqDeserializer},
8 DeserializeSeed, Deserializer, MapAccess, Visitor,
9};
10
11pub struct DataDeserializer<'a> {
12 names_iter: Iter<'a, Vec<u8>>,
13 values_iter: Peekable<Iter<'a, Value>>,
14 field: usize,
15}
16
17impl<'a> DataDeserializer<'a> {
18 pub fn new(names: &'a [Vec<u8>], values: &'a [Value]) -> Self {
19 let names_iter = names.iter();
20 let values_iter = values.iter().peekable();
21
22 Self {
23 names_iter,
24 values_iter,
25 field: 0,
26 }
27 }
28
29 fn next_name(&mut self) -> Option<&'a Vec<u8>> {
30 self.names_iter.next()
31 }
32
33 fn next_value(&mut self) -> Result<&'a Value, DataDeserializeError> {
34 match self.values_iter.next() {
35 Some(row) => {
36 self.field += 1;
37 Ok(row)
38 }
39 None => Err(DataDeserializeError::new(
40 None,
41 DataDeserializeErrorKind::UnexpectedEndOf,
42 )),
43 }
44 }
45
46 fn peek_value(&mut self) -> Option<&&'a Value> {
47 self.values_iter.peek()
48 }
49
50 fn error(&self, kind: DataDeserializeErrorKind) -> DataDeserializeError {
51 DataDeserializeError::new(Some(self.field.saturating_sub(1)), kind)
52 }
53}
54
55impl<'a, 'de> Deserializer<'de> for &'a mut DataDeserializer<'de> {
56 type Error = DataDeserializeError;
57
58 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
59 where
60 V: Visitor<'de>,
61 {
62 Err(self.error(DataDeserializeErrorKind::Unimplemented))
63 }
64
65 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
66 where
67 V: Visitor<'de>,
68 {
69 match self.next_value()? {
70 Value::bVal(v) => visitor.visit_bool(*v),
71 Value::UnknownField(v) => {
72 assert_eq!(v, &-1);
73 visitor.visit_bool(Default::default())
74 }
75 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
76 }
77 }
78
79 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
80 where
81 V: Visitor<'de>,
82 {
83 match self.next_value()? {
84 Value::iVal(v) => match i8::try_from(*v) {
85 Ok(v) => visitor.visit_i8(v),
86 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
87 },
88 Value::UnknownField(v) => {
89 assert_eq!(v, &-1);
90 visitor.visit_i8(Default::default())
91 }
92 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
93 }
94 }
95
96 fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
97 where
98 V: Visitor<'de>,
99 {
100 match self.next_value()? {
101 Value::iVal(v) => match i16::try_from(*v) {
102 Ok(v) => visitor.visit_i16(v),
103 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
104 },
105 Value::UnknownField(v) => {
106 assert_eq!(v, &-1);
107 visitor.visit_i16(Default::default())
108 }
109 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
110 }
111 }
112
113 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
114 where
115 V: Visitor<'de>,
116 {
117 match self.next_value()? {
118 Value::iVal(v) => match i32::try_from(*v) {
119 Ok(v) => visitor.visit_i32(v),
120 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
121 },
122 Value::UnknownField(v) => {
123 assert_eq!(v, &-1);
124 visitor.visit_i32(Default::default())
125 }
126 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
127 }
128 }
129
130 fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
131 where
132 V: Visitor<'de>,
133 {
134 match self.next_value()? {
135 Value::iVal(v) => visitor.visit_i64(*v),
136 Value::UnknownField(v) => {
137 assert_eq!(v, &-1);
138 visitor.visit_i64(Default::default())
139 }
140 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
141 }
142 }
143
144 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
145 where
146 V: Visitor<'de>,
147 {
148 match self.next_value()? {
149 Value::iVal(v) => match u8::try_from(*v) {
150 Ok(v) => visitor.visit_u8(v),
151 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
152 },
153 Value::sVal(v) => visitor.visit_u8(v[0]),
154 Value::UnknownField(v) => {
155 assert_eq!(v, &-1);
156 visitor.visit_u8(Default::default())
157 }
158 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
159 }
160 }
161
162 fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
163 where
164 V: Visitor<'de>,
165 {
166 match self.next_value()? {
167 Value::iVal(v) => match u16::try_from(*v) {
168 Ok(v) => visitor.visit_u16(v),
169 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
170 },
171 Value::UnknownField(v) => {
172 assert_eq!(v, &-1);
173 visitor.visit_u16(Default::default())
174 }
175 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
176 }
177 }
178
179 fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
180 where
181 V: Visitor<'de>,
182 {
183 match self.next_value()? {
184 Value::iVal(v) => match u32::try_from(*v) {
185 Ok(v) => visitor.visit_u32(v),
186 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
187 },
188 Value::UnknownField(v) => {
189 assert_eq!(v, &-1);
190 visitor.visit_u32(Default::default())
191 }
192 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
193 }
194 }
195
196 fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
197 where
198 V: Visitor<'de>,
199 {
200 match self.next_value()? {
201 Value::iVal(v) => match u64::try_from(*v) {
202 Ok(v) => visitor.visit_u64(v),
203 Err(_) => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
204 },
205 Value::UnknownField(v) => {
206 assert_eq!(v, &-1);
207 visitor.visit_u64(Default::default())
208 }
209 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
210 }
211 }
212
213 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
214 where
215 V: Visitor<'de>,
216 {
217 match self.next_value()? {
218 Value::fVal(v) => visitor.visit_f32(v.0 as f32),
219 Value::UnknownField(v) => {
220 assert_eq!(v, &-1);
221 visitor.visit_f32(Default::default())
222 }
223 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
224 }
225 }
226
227 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
228 where
229 V: Visitor<'de>,
230 {
231 match self.next_value()? {
232 Value::fVal(v) => visitor.visit_f64(v.0),
233 Value::UnknownField(v) => {
234 assert_eq!(v, &-1);
235 visitor.visit_f64(Default::default())
236 }
237 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
238 }
239 }
240
241 fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
242 where
243 V: Visitor<'de>,
244 {
245 Err(self.error(DataDeserializeErrorKind::Unimplemented))
246 }
247
248 fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
249 where
250 V: Visitor<'de>,
251 {
252 Err(self.error(DataDeserializeErrorKind::Unimplemented))
253 }
254
255 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
256 where
257 V: Visitor<'de>,
258 {
259 match self.next_value()? {
260 Value::sVal(v) => visitor.visit_string(String::from_utf8_lossy(v).to_string()),
261 Value::UnknownField(v) => {
262 assert_eq!(v, &-1);
263 visitor.visit_string(Default::default())
264 }
265 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
266 }
267 }
268
269 fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
270 where
271 V: Visitor<'de>,
272 {
273 Err(self.error(DataDeserializeErrorKind::Unimplemented))
274 }
275
276 fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
277 where
278 V: Visitor<'de>,
279 {
280 Err(self.error(DataDeserializeErrorKind::Unimplemented))
281 }
282
283 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
284 where
285 V: Visitor<'de>,
286 {
287 match self.peek_value() {
288 Some(_) => visitor.visit_some(self),
289 None => visitor.visit_none(),
290 }
291 }
292
293 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
294 where
295 V: Visitor<'de>,
296 {
297 visitor.visit_unit()
298 }
299
300 fn deserialize_unit_struct<V>(
301 self,
302 _name: &'static str,
303 _visitor: V,
304 ) -> Result<V::Value, Self::Error>
305 where
306 V: Visitor<'de>,
307 {
308 Err(self.error(DataDeserializeErrorKind::Unimplemented))
309 }
310
311 fn deserialize_newtype_struct<V>(
312 self,
313 _name: &'static str,
314 visitor: V,
315 ) -> Result<V::Value, Self::Error>
316 where
317 V: Visitor<'de>,
318 {
319 visitor.visit_newtype_struct(self)
320 }
321
322 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
323 where
324 V: Visitor<'de>,
325 {
326 match self.next_value()? {
327 Value::sVal(v) => {
328 let mut seq_deserializer = SeqDeserializer::new(v.iter().copied());
329 let value = visitor.visit_seq(&mut seq_deserializer)?;
330 seq_deserializer.end()?;
331 Ok(value)
332 }
333 Value::UnknownField(v) => {
334 assert_eq!(v, &-1);
335 let v: Vec<u8> = Default::default();
336 let mut seq_deserializer = SeqDeserializer::new(v.iter().copied());
337 let value = visitor.visit_seq(&mut seq_deserializer)?;
338 seq_deserializer.end()?;
339 Ok(value)
340 }
341 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
342 }
343 }
344
345 fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
346 where
347 V: Visitor<'de>,
348 {
349 match self.next_value()? {
350 Value::dVal(v) => {
351 let mut seq_deserializer =
352 SeqDeserializer::new(vec![v.year, v.month as i16, v.day as i16].into_iter());
353 let value = visitor.visit_seq(&mut seq_deserializer)?;
354 seq_deserializer.end()?;
355 Ok(value)
356 }
357 Value::tVal(v) => {
358 let mut seq_deserializer = SeqDeserializer::new(
359 vec![
360 v.hour as i16,
361 v.minute as i16,
362 v.sec as i16,
363 v.microsec.div(1000) as i16,
364 ]
365 .into_iter(),
366 );
367 let value = visitor.visit_seq(&mut seq_deserializer)?;
368 seq_deserializer.end()?;
369 Ok(value)
370 }
371 Value::dtVal(v) => {
372 let mut seq_deserializer = SeqDeserializer::new(
373 vec![
374 v.year,
375 v.month as i16,
376 v.day as i16,
377 v.hour as i16,
378 v.minute as i16,
379 v.sec as i16,
380 v.microsec.div(1000) as i16,
381 0i16,
382 ]
383 .into_iter(),
384 );
385 let value = visitor.visit_seq(&mut seq_deserializer)?;
386 seq_deserializer.end()?;
387 Ok(value)
388 }
389 Value::UnknownField(v) => {
390 assert_eq!(v, &-1);
391 let v: Vec<u8> = Default::default();
393 let mut seq_deserializer = SeqDeserializer::new(v.iter().copied());
394 let value = visitor.visit_seq(&mut seq_deserializer)?;
395 seq_deserializer.end()?;
396 Ok(value)
397 }
398 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
399 }
400 }
401
402 fn deserialize_tuple_struct<V>(
403 self,
404 _name: &'static str,
405 _len: usize,
406 visitor: V,
407 ) -> Result<V::Value, Self::Error>
408 where
409 V: Visitor<'de>,
410 {
411 match self.next_value()? {
412 Value::dVal(v) => {
413 let mut seq_deserializer =
414 SeqDeserializer::new(vec![v.year, v.month as i16, v.day as i16].into_iter());
415 let value = visitor.visit_seq(&mut seq_deserializer)?;
416 seq_deserializer.end()?;
417 Ok(value)
418 }
419 Value::tVal(v) => {
420 let mut seq_deserializer = SeqDeserializer::new(
421 vec![
422 v.hour as i16,
423 v.minute as i16,
424 v.sec as i16,
425 v.microsec.div(1000) as i16,
426 ]
427 .into_iter(),
428 );
429 let value = visitor.visit_seq(&mut seq_deserializer)?;
430 seq_deserializer.end()?;
431 Ok(value)
432 }
433 Value::dtVal(v) => {
434 let mut seq_deserializer = SeqDeserializer::new(
435 vec![
436 v.year,
437 v.month as i16,
438 v.day as i16,
439 v.hour as i16,
440 v.minute as i16,
441 v.sec as i16,
442 v.microsec.div(1000) as i16,
443 0i16,
444 ]
445 .into_iter(),
446 );
447 let value = visitor.visit_seq(&mut seq_deserializer)?;
448 seq_deserializer.end()?;
449 Ok(value)
450 }
451 Value::UnknownField(v) => {
452 assert_eq!(v, &-1);
453 let v: Vec<u8> = Default::default();
455 let mut seq_deserializer = SeqDeserializer::new(v.iter().copied());
456 let value = visitor.visit_seq(&mut seq_deserializer)?;
457 seq_deserializer.end()?;
458 Ok(value)
459 }
460 _ => Err(self.error(DataDeserializeErrorKind::TypeMismatch)),
461 }
462 }
463
464 fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
465 where
466 V: Visitor<'de>,
467 {
468 Err(self.error(DataDeserializeErrorKind::Unimplemented))
469 }
470
471 fn deserialize_struct<V>(
472 self,
473 _name: &'static str,
474 _fields: &'static [&'static str],
475 visitor: V,
476 ) -> Result<V::Value, Self::Error>
477 where
478 V: Visitor<'de>,
479 {
480 visitor.visit_map(self)
481 }
482
483 fn deserialize_enum<V>(
484 self,
485 _name: &'static str,
486 _variants: &'static [&'static str],
487 _visitor: V,
488 ) -> Result<V::Value, Self::Error>
489 where
490 V: Visitor<'de>,
491 {
492 Err(self.error(DataDeserializeErrorKind::Unimplemented))
493 }
494
495 fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
496 where
497 V: Visitor<'de>,
498 {
499 Err(self.error(DataDeserializeErrorKind::Unimplemented))
500 }
501
502 fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
503 where
504 V: Visitor<'de>,
505 {
506 let _ = self.next_value()?;
508 visitor.visit_unit()
509 }
510
511 fn is_human_readable(&self) -> bool {
512 true
513 }
514}
515
516impl<'a, 'de> MapAccess<'de> for &'a mut DataDeserializer<'de> {
517 type Error = DataDeserializeError;
518
519 fn next_key_seed<K: DeserializeSeed<'de>>(
520 &mut self,
521 seed: K,
522 ) -> Result<Option<K::Value>, Self::Error> {
523 let name = match self.next_name() {
524 Some(name) => name,
525 None => return Ok(None),
526 };
527 seed.deserialize(BorrowedBytesDeserializer::new(name))
528 .map(Some)
529 }
530
531 fn next_value_seed<K: DeserializeSeed<'de>>(
532 &mut self,
533 seed: K,
534 ) -> Result<K::Value, Self::Error> {
535 seed.deserialize(&mut **self)
536 }
537}
538
539#[derive(Clone, Debug, Eq, PartialEq)]
543pub struct DataDeserializeError {
544 pub field: Option<usize>,
545 pub kind: DataDeserializeErrorKind,
546}
547impl DataDeserializeError {
548 pub fn new(field: Option<usize>, kind: DataDeserializeErrorKind) -> Self {
549 Self { field, kind }
550 }
551}
552
553#[derive(Clone, Debug, Eq, PartialEq)]
554pub enum DataDeserializeErrorKind {
555 UnexpectedEndOf,
556 TypeMismatch,
557 Unimplemented,
558 Custom(String),
559}
560
561impl DataDeserializeErrorKind {
562 #[allow(deprecated)]
563 fn description(&self) -> &str {
564 use self::DataDeserializeErrorKind::*;
565
566 match *self {
567 UnexpectedEndOf => "Unexpected end of",
568 TypeMismatch => "Type mismatch",
569 Unimplemented => "Unimplemented",
570 Custom(ref msg) => msg,
571 }
572 }
573}
574
575impl std::error::Error for DataDeserializeError {
576 fn description(&self) -> &str {
577 self.kind.description()
578 }
579}
580
581impl de::Error for DataDeserializeError {
582 fn custom<T: core::fmt::Display>(msg: T) -> DataDeserializeError {
583 DataDeserializeError {
584 field: None,
585 kind: DataDeserializeErrorKind::Custom(msg.to_string()),
586 }
587 }
588}
589
590impl core::fmt::Display for DataDeserializeError {
591 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
592 if let Some(field) = self.field {
593 write!(f, "field {field}: {}", self.kind)
594 } else {
595 write!(f, "{}", self.kind)
596 }
597 }
598}
599
600impl core::fmt::Display for DataDeserializeErrorKind {
601 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
602 use self::DataDeserializeErrorKind::*;
603
604 match *self {
605 UnexpectedEndOf => write!(f, "{}", self.description()),
606 TypeMismatch => write!(f, "{}", self.description()),
607 Unimplemented => write!(f, "{}", self.description()),
608 Custom(ref msg) => write!(f, "{msg}"),
609 }
610 }
611}
612
613impl From<DataDeserializeError> for IoError {
614 fn from(err: DataDeserializeError) -> IoError {
615 IoError::new(IoErrorKind::InvalidInput, err)
616 }
617}
618
619#[cfg(test)]
620mod tests {
621 use super::*;
622
623 use float_cmp::approx_eq;
624 use nebula_fbthrift_graph_v3::dependencies::common::{double::Double, types};
625 use serde::{de::DeserializeOwned, Deserialize};
626 use serde_repr::Deserialize_repr;
627
628 use crate::datetime::{self, Date, Day, Hour, Millisec, Minute, Month, Second, Time, Year};
629
630 fn de<D: DeserializeOwned>(
631 names: Vec<&str>,
632 values: Vec<Value>,
633 ) -> Result<D, Box<dyn std::error::Error>> {
634 let names: Vec<_> = names.into_iter().map(|x| x.as_bytes().to_vec()).collect();
635
636 let mut data_deserializer = DataDeserializer::new(&names, &values);
637
638 D::deserialize(&mut data_deserializer).map_err(Into::into)
639 }
640
641 #[test]
642 fn with_b_val() -> Result<(), Box<dyn std::error::Error>> {
643 #[derive(Deserialize)]
644 struct Foo {
645 a: bool,
646 b: bool,
647 }
648
649 let v: Foo = de(vec!["a", "b"], vec![Value::bVal(true), Value::bVal(false)])?;
650
651 assert!(v.a);
652 assert!(!v.b);
653
654 Ok(())
655 }
656
657 #[test]
658 fn with_i_val() -> Result<(), Box<dyn std::error::Error>> {
659 #[derive(Deserialize_repr, PartialEq, Debug)]
660 #[repr(u8)]
661 enum State {
662 Pending = 1,
663 Done = 2,
664 }
665
666 #[derive(Deserialize)]
667 struct Foo {
668 a: i64,
669 b: i32,
670 c: i16,
671 d: i8,
672 e: u64,
673 f: u32,
674 g: u16,
675 h: u8,
676 state: State,
677 }
678
679 let v: Foo = de(
680 vec!["a", "b", "c", "d", "e", "f", "g", "h", "state"],
681 vec![
682 Value::iVal(1),
683 Value::iVal(2),
684 Value::iVal(3),
685 Value::iVal(4),
686 Value::iVal(5),
687 Value::iVal(6),
688 Value::iVal(7),
689 Value::iVal(8),
690 Value::iVal(2),
691 ],
692 )?;
693
694 assert_eq!(v.a, 1);
695 assert_eq!(v.b, 2);
696 assert_eq!(v.c, 3);
697 assert_eq!(v.d, 4);
698 assert_eq!(v.e, 5);
699 assert_eq!(v.f, 6);
700 assert_eq!(v.g, 7);
701 assert_eq!(v.h, 8);
702 assert_eq!(v.state, State::Done);
703
704 Ok(())
705 }
706
707 #[test]
708 fn with_f_val() -> Result<(), Box<dyn std::error::Error>> {
709 #[derive(Deserialize)]
710 struct Foo {
711 a: f64,
712 }
713
714 let v: Foo = de(vec!["a"], vec![Value::fVal(Double(1_f64))])?;
715
716 assert!(approx_eq!(f64, v.a, 1_f64));
717
718 Ok(())
719 }
720
721 #[test]
722 fn with_s_val() -> Result<(), Box<dyn std::error::Error>> {
723 #[derive(Deserialize)]
724 struct Foo {
725 a: String,
726 b: Vec<u8>,
727 }
728
729 let v: Foo = de(
730 vec!["a", "b"],
731 vec![
732 Value::sVal(b"String".to_vec()),
733 Value::sVal(b"Vec<u8>".to_vec()),
734 ],
735 )?;
736
737 assert_eq!(v.a, "String");
738 assert_eq!(v.b, b"Vec<u8>");
739
740 Ok(())
741 }
742
743 #[test]
744 fn with_d_val() -> Result<(), Box<dyn std::error::Error>> {
745 #[derive(Deserialize)]
746 struct Foo {
747 a: (Year, Month, Day),
748 b: Date,
749 }
750
751 let v: Foo = de(
752 vec!["a", "b"],
753 vec![
754 Value::dVal(types::Date {
755 year: 2020,
756 month: 1,
757 day: 2,
758 ..Default::default()
759 }),
760 Value::dVal(types::Date {
761 year: 2020,
762 month: 1,
763 day: 3,
764 ..Default::default()
765 }),
766 ],
767 )?;
768
769 assert_eq!(v.a, (2020, 1, 2));
770 assert_eq!(v.b, Date(2020, 1, 3));
771
772 Ok(())
773 }
774
775 #[test]
776 fn with_t_val() -> Result<(), Box<dyn std::error::Error>> {
777 #[derive(Deserialize)]
778 struct Foo {
779 a: (Hour, Minute, Second, Millisec),
780 b: Time,
781 }
782
783 let v: Foo = de(
784 vec!["a", "b"],
785 vec![
786 Value::tVal(types::Time {
787 hour: 1,
788 minute: 2,
789 sec: 3,
790 microsec: 8001,
791 ..Default::default()
792 }),
793 Value::tVal(types::Time {
794 hour: 4,
795 minute: 5,
796 sec: 6,
797 microsec: 9001,
798 ..Default::default()
799 }),
800 ],
801 )?;
802
803 assert_eq!(v.a, (1, 2, 3, 8));
804 assert_eq!(v.b, Time(4, 5, 6, 9));
805
806 Ok(())
807 }
808
809 #[test]
810 fn with_dt_val() -> Result<(), Box<dyn std::error::Error>> {
811 #[derive(Deserialize)]
812 struct Foo {
813 a: datetime::DateTime,
814 }
815
816 let v: Foo = de(
817 vec!["a"],
818 vec![Value::dtVal(types::DateTime {
819 year: 2020,
820 month: 1,
821 day: 2,
822 hour: 3,
823 minute: 4,
824 sec: 5,
825 microsec: 9001,
826 ..Default::default()
827 })],
828 )?;
829
830 assert_eq!(v.a, datetime::DateTime(2020, 1, 2, 3, 4, 5, 9, 0));
831
832 Ok(())
833 }
834
835 #[test]
836 fn with_unknown_field() -> Result<(), Box<dyn std::error::Error>> {
837 #[derive(Deserialize)]
838 struct Foo {
839 a: i32,
840 }
841
842 let v: Foo = de(vec!["a"], vec![Value::UnknownField(-1)])?;
843
844 assert_eq!(v.a, 0);
845
846 Ok(())
847 }
848
849 #[test]
850 fn with_multiple() -> Result<(), Box<dyn std::error::Error>> {
851 #[derive(Deserialize)]
852 struct Foo {
853 a: bool,
854 b: i64,
855 c: String,
856 }
857
858 let v: Foo = de(
859 vec!["a", "b", "c"],
860 vec![
861 Value::bVal(true),
862 Value::iVal(1),
863 Value::sVal(b"3".to_vec()),
864 ],
865 )?;
866
867 assert!(v.a);
868 assert_eq!(v.b, 1);
869 assert_eq!(v.c, "3");
870
871 Ok(())
872 }
873
874 #[test]
875 fn with_unit() -> Result<(), Box<dyn std::error::Error>> {
876 de::<()>(vec!["a"], vec![Value::bVal(true)])?;
877
878 Ok(())
879 }
880
881 #[test]
882 fn with_option() -> Result<(), Box<dyn std::error::Error>> {
883 #[derive(Deserialize)]
884 struct Foo {
885 a: Option<bool>,
886 }
887
888 let v: Foo = de(vec!["a"], vec![Value::bVal(true)])?;
889
890 assert_eq!(v.a, Some(true));
891
892 Ok(())
893 }
894}