1 use core::convert::TryFrom;
2
3 use serde::de::{self, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, Visitor};
4 use static_assertions::assert_impl_all;
5
6 use std::{marker::PhantomData, os::unix::io::RawFd, str};
7
8 use crate::{
9 de::ValueParseStage, signature_parser::SignatureParser, utils::*, Basic, EncodingContext,
10 EncodingFormat, Error, Fd, ObjectPath, Result, Signature,
11 };
12
13 /// Our D-Bus deserialization implementation.
14 #[derive(Debug)]
15 pub struct Deserializer<'de, 'sig, 'f, B>(pub(crate) crate::DeserializerCommon<'de, 'sig, 'f, B>);
16
17 assert_impl_all!(Deserializer<'_, '_, '_, i32>: Send, Sync, Unpin);
18
19 impl<'de, 'sig, 'f, B> Deserializer<'de, 'sig, 'f, B>
20 where
21 B: byteorder::ByteOrder,
22 {
23 /// Create a Deserializer struct instance.
new<'r: 'de>( bytes: &'r [u8], fds: Option<&'f [RawFd]>, signature: &Signature<'sig>, ctxt: EncodingContext<B>, ) -> Self24 pub fn new<'r: 'de>(
25 bytes: &'r [u8],
26 fds: Option<&'f [RawFd]>,
27 signature: &Signature<'sig>,
28 ctxt: EncodingContext<B>,
29 ) -> Self {
30 assert_eq!(ctxt.format(), EncodingFormat::DBus);
31
32 let sig_parser = SignatureParser::new(signature.clone());
33 Self(crate::DeserializerCommon {
34 ctxt,
35 sig_parser,
36 bytes,
37 fds,
38 pos: 0,
39 b: PhantomData,
40 })
41 }
42 }
43
44 macro_rules! deserialize_basic {
45 ($method:ident $read_method:ident $visitor_method:ident($type:ty)) => {
46 fn $method<V>(self, visitor: V) -> Result<V::Value>
47 where
48 V: Visitor<'de>,
49 {
50 let v = B::$read_method(self.0.next_const_size_slice::<$type>()?);
51
52 visitor.$visitor_method(v)
53 }
54 };
55 }
56
57 macro_rules! deserialize_as {
58 ($method:ident => $as:ident) => {
59 deserialize_as!($method() => $as());
60 };
61 ($method:ident($($in_arg:ident: $type:ty),*) => $as:ident($($as_arg:expr),*)) => {
62 #[inline]
63 fn $method<V>(self, $($in_arg: $type,)* visitor: V) -> Result<V::Value>
64 where
65 V: Visitor<'de>,
66 {
67 self.$as($($as_arg,)* visitor)
68 }
69 }
70 }
71
72 impl<'de, 'd, 'sig, 'f, B> de::Deserializer<'de> for &'d mut Deserializer<'de, 'sig, 'f, B>
73 where
74 B: byteorder::ByteOrder,
75 {
76 type Error = Error;
77
deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,78 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
79 where
80 V: Visitor<'de>,
81 {
82 let c = self.0.sig_parser.next_char();
83
84 crate::de::deserialize_any::<B, Self, V>(self, c, visitor)
85 }
86
deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,87 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
88 where
89 V: Visitor<'de>,
90 {
91 let v = B::read_u32(self.0.next_const_size_slice::<bool>()?);
92 let b = match v {
93 1 => true,
94 0 => false,
95 // As per D-Bus spec, only 0 and 1 values are allowed
96 _ => {
97 return Err(de::Error::invalid_value(
98 de::Unexpected::Unsigned(v as u64),
99 &"0 or 1",
100 ))
101 }
102 };
103
104 visitor.visit_bool(b)
105 }
106
deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,107 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
108 where
109 V: Visitor<'de>,
110 {
111 self.deserialize_i16(visitor)
112 }
113
114 deserialize_basic!(deserialize_i16 read_i16 visit_i16(i16));
115 deserialize_basic!(deserialize_i64 read_i64 visit_i64(i64));
116 deserialize_basic!(deserialize_u16 read_u16 visit_u16(u16));
117 deserialize_basic!(deserialize_u32 read_u32 visit_u32(u32));
118 deserialize_basic!(deserialize_u64 read_u64 visit_u64(u64));
119 deserialize_basic!(deserialize_f64 read_f64 visit_f64(f64));
120
deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,121 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
122 where
123 V: Visitor<'de>,
124 {
125 let bytes = deserialize_ay(self)?;
126 visitor.visit_byte_buf(bytes.into())
127 }
128
deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,129 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
130 where
131 V: Visitor<'de>,
132 {
133 let bytes = deserialize_ay(self)?;
134 visitor.visit_borrowed_bytes(bytes)
135 }
136
137 deserialize_as!(deserialize_char => deserialize_str);
138 deserialize_as!(deserialize_string => deserialize_str);
139 deserialize_as!(deserialize_tuple(_l: usize) => deserialize_struct("", &[]));
140 deserialize_as!(deserialize_tuple_struct(n: &'static str, _l: usize) => deserialize_struct(n, &[]));
141 deserialize_as!(deserialize_struct(_n: &'static str, _f: &'static [&'static str]) => deserialize_seq());
142 deserialize_as!(deserialize_map => deserialize_seq);
143 deserialize_as!(deserialize_ignored_any => deserialize_any);
144
deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,145 fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
146 where
147 V: Visitor<'de>,
148 {
149 let v = match self.0.sig_parser.next_char() {
150 Fd::SIGNATURE_CHAR => {
151 self.0.sig_parser.skip_char()?;
152 let alignment = u32::alignment(EncodingFormat::DBus);
153 self.0.parse_padding(alignment)?;
154 let idx = B::read_u32(self.0.next_slice(alignment)?);
155 self.0.get_fd(idx)?
156 }
157 _ => B::read_i32(self.0.next_const_size_slice::<i32>()?),
158 };
159
160 visitor.visit_i32(v)
161 }
162
deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,163 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
164 where
165 V: Visitor<'de>,
166 {
167 // Endianness is irrelevant for single bytes.
168 visitor.visit_u8(self.0.next_const_size_slice::<u8>().map(|bytes| bytes[0])?)
169 }
170
deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,171 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
172 where
173 V: Visitor<'de>,
174 {
175 let v = B::read_f64(self.0.next_const_size_slice::<f64>()?);
176
177 visitor.visit_f32(f64_to_f32(v))
178 }
179
deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,180 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
181 where
182 V: Visitor<'de>,
183 {
184 let len = match self.0.sig_parser.next_char() {
185 Signature::SIGNATURE_CHAR | VARIANT_SIGNATURE_CHAR => {
186 let len_slice = self.0.next_slice(1)?;
187
188 len_slice[0] as usize
189 }
190 <&str>::SIGNATURE_CHAR | ObjectPath::SIGNATURE_CHAR => {
191 let alignment = u32::alignment(EncodingFormat::DBus);
192 self.0.parse_padding(alignment)?;
193 let len_slice = self.0.next_slice(alignment)?;
194
195 B::read_u32(len_slice) as usize
196 }
197 c => {
198 let expected = format!(
199 "`{}`, `{}`, `{}` or `{}`",
200 <&str>::SIGNATURE_STR,
201 Signature::SIGNATURE_STR,
202 ObjectPath::SIGNATURE_STR,
203 VARIANT_SIGNATURE_CHAR,
204 );
205 return Err(de::Error::invalid_type(
206 de::Unexpected::Char(c),
207 &expected.as_str(),
208 ));
209 }
210 };
211 let slice = self.0.next_slice(len)?;
212 if slice.contains(&0) {
213 return Err(serde::de::Error::invalid_value(
214 serde::de::Unexpected::Char('\0'),
215 &"D-Bus string type must not contain interior null bytes",
216 ));
217 }
218 self.0.pos += 1; // skip trailing null byte
219 let s = str::from_utf8(slice).map_err(Error::Utf8)?;
220 self.0.sig_parser.skip_char()?;
221
222 visitor.visit_borrowed_str(s)
223 }
224
deserialize_option<V>(self, _visitor: V) -> Result<V::Value> where V: Visitor<'de>,225 fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value>
226 where
227 V: Visitor<'de>,
228 {
229 unreachable!("DBus format can't support `Option`");
230 }
231
deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,232 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
233 where
234 V: Visitor<'de>,
235 {
236 visitor.visit_unit()
237 }
238
deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> where V: Visitor<'de>,239 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
240 where
241 V: Visitor<'de>,
242 {
243 visitor.visit_unit()
244 }
245
deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> where V: Visitor<'de>,246 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
247 where
248 V: Visitor<'de>,
249 {
250 visitor.visit_newtype_struct(self)
251 }
252
deserialize_seq<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,253 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
254 where
255 V: Visitor<'de>,
256 {
257 match self.0.sig_parser.next_char() {
258 VARIANT_SIGNATURE_CHAR => {
259 let value_de = ValueDeserializer::new(self);
260
261 visitor.visit_seq(value_de)
262 }
263 ARRAY_SIGNATURE_CHAR => {
264 self.0.sig_parser.skip_char()?;
265 let next_signature_char = self.0.sig_parser.next_char();
266 let array_de = ArrayDeserializer::new(self)?;
267
268 if next_signature_char == DICT_ENTRY_SIG_START_CHAR {
269 visitor.visit_map(ArrayMapDeserializer(array_de))
270 } else {
271 visitor.visit_seq(ArraySeqDeserializer(array_de))
272 }
273 }
274 STRUCT_SIG_START_CHAR => {
275 let signature = self.0.sig_parser.next_signature()?;
276 let alignment = alignment_for_signature(&signature, EncodingFormat::DBus);
277 self.0.parse_padding(alignment)?;
278
279 self.0.sig_parser.skip_char()?;
280
281 visitor.visit_seq(StructureDeserializer { de: self })
282 }
283 c => Err(de::Error::invalid_type(
284 de::Unexpected::Char(c),
285 &format!(
286 "`{}`, `{}` or `{}`",
287 VARIANT_SIGNATURE_CHAR, ARRAY_SIGNATURE_CHAR, STRUCT_SIG_START_CHAR,
288 )
289 .as_str(),
290 )),
291 }
292 }
293
deserialize_enum<V>( self, name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value> where V: Visitor<'de>,294 fn deserialize_enum<V>(
295 self,
296 name: &'static str,
297 _variants: &'static [&'static str],
298 visitor: V,
299 ) -> Result<V::Value>
300 where
301 V: Visitor<'de>,
302 {
303 visitor.visit_enum(crate::de::Enum {
304 de: self,
305 name,
306 phantom: PhantomData,
307 })
308 }
309
deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,310 fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
311 where
312 V: Visitor<'de>,
313 {
314 // Not using serialize_u32 cause identifier isn't part of the signature
315 let alignment = u32::alignment(EncodingFormat::DBus);
316 self.0.parse_padding(alignment)?;
317 let variant_index =
318 crate::from_slice_fds::<B, _>(&self.0.bytes[self.0.pos..], self.0.fds, self.0.ctxt)?;
319 self.0.pos += alignment;
320
321 visitor.visit_u32(variant_index)
322 }
323 }
324
325 struct ArrayDeserializer<'d, 'de, 'sig, 'f, B> {
326 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
327 len: usize,
328 start: usize,
329 // alignment of element
330 element_alignment: usize,
331 // where value signature starts
332 element_signature_len: usize,
333 }
334
335 impl<'d, 'de, 'sig, 'f, B> ArrayDeserializer<'d, 'de, 'sig, 'f, B>
336 where
337 B: byteorder::ByteOrder,
338 {
new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self>339 fn new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self> {
340 de.0.parse_padding(ARRAY_ALIGNMENT_DBUS)?;
341
342 let len = B::read_u32(de.0.next_slice(4)?) as usize;
343 let element_signature = de.0.sig_parser.next_signature()?;
344 let element_alignment = alignment_for_signature(&element_signature, EncodingFormat::DBus);
345 let mut element_signature_len = element_signature.len();
346
347 // D-Bus requires padding for the first element even when there is no first element
348 // (i-e empty array) so we parse padding already.
349 de.0.parse_padding(element_alignment)?;
350 let start = de.0.pos;
351
352 if de.0.sig_parser.next_char() == DICT_ENTRY_SIG_START_CHAR {
353 de.0.sig_parser.skip_char()?;
354 element_signature_len -= 1;
355 }
356
357 Ok(Self {
358 de,
359 len,
360 start,
361 element_alignment,
362 element_signature_len,
363 })
364 }
365
next<T>(&mut self, seed: T, sig_parser: SignatureParser<'_>) -> Result<T::Value> where T: DeserializeSeed<'de>,366 fn next<T>(&mut self, seed: T, sig_parser: SignatureParser<'_>) -> Result<T::Value>
367 where
368 T: DeserializeSeed<'de>,
369 {
370 let ctxt = EncodingContext::new_dbus(self.de.0.ctxt.position() + self.de.0.pos);
371
372 let mut de = Deserializer::<B>(crate::DeserializerCommon {
373 ctxt,
374 sig_parser,
375 bytes: &self.de.0.bytes[self.de.0.pos..],
376 fds: self.de.0.fds,
377 pos: 0,
378 b: PhantomData,
379 });
380 let v = seed.deserialize(&mut de);
381 self.de.0.pos += de.0.pos;
382
383 if self.de.0.pos > self.start + self.len {
384 return Err(serde::de::Error::invalid_length(
385 self.len,
386 &format!(">= {}", self.de.0.pos - self.start).as_str(),
387 ));
388 }
389
390 v
391 }
392
next_element<T>( &mut self, seed: T, sig_parser: SignatureParser<'_>, ) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,393 fn next_element<T>(
394 &mut self,
395 seed: T,
396 sig_parser: SignatureParser<'_>,
397 ) -> Result<Option<T::Value>>
398 where
399 T: DeserializeSeed<'de>,
400 {
401 if self.done() {
402 self.de
403 .0
404 .sig_parser
405 .skip_chars(self.element_signature_len)?;
406
407 return Ok(None);
408 }
409
410 self.de.0.parse_padding(self.element_alignment)?;
411
412 self.next(seed, sig_parser).map(Some)
413 }
414
done(&self) -> bool415 fn done(&self) -> bool {
416 self.de.0.pos == self.start + self.len
417 }
418 }
419
deserialize_ay<'de, 'sig, 'f, B>(de: &mut Deserializer<'de, 'sig, 'f, B>) -> Result<&'de [u8]> where B: byteorder::ByteOrder,420 fn deserialize_ay<'de, 'sig, 'f, B>(de: &mut Deserializer<'de, 'sig, 'f, B>) -> Result<&'de [u8]>
421 where
422 B: byteorder::ByteOrder,
423 {
424 if de.0.sig_parser.next_signature()? != "ay" {
425 return Err(de::Error::invalid_type(de::Unexpected::Seq, &"ay"));
426 }
427
428 de.0.sig_parser.skip_char()?;
429 let ad = ArrayDeserializer::new(de)?;
430 let len = ad.len;
431 de.0.sig_parser.skip_char()?;
432 de.0.next_slice(len)
433 }
434
435 struct ArraySeqDeserializer<'d, 'de, 'sig, 'f, B>(ArrayDeserializer<'d, 'de, 'sig, 'f, B>);
436
437 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for ArraySeqDeserializer<'d, 'de, 'sig, 'f, B>
438 where
439 B: byteorder::ByteOrder,
440 {
441 type Error = Error;
442
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,443 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
444 where
445 T: DeserializeSeed<'de>,
446 {
447 let sig_parser = self.0.de.0.sig_parser.clone();
448 self.0.next_element(seed, sig_parser)
449 }
450 }
451
452 struct ArrayMapDeserializer<'d, 'de, 'sig, 'f, B>(ArrayDeserializer<'d, 'de, 'sig, 'f, B>);
453
454 impl<'d, 'de, 'sig, 'f, B> MapAccess<'de> for ArrayMapDeserializer<'d, 'de, 'sig, 'f, B>
455 where
456 B: byteorder::ByteOrder,
457 {
458 type Error = Error;
459
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> where K: DeserializeSeed<'de>,460 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
461 where
462 K: DeserializeSeed<'de>,
463 {
464 let sig_parser = self.0.de.0.sig_parser.clone();
465 self.0.next_element(seed, sig_parser)
466 }
467
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where V: DeserializeSeed<'de>,468 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
469 where
470 V: DeserializeSeed<'de>,
471 {
472 let mut sig_parser = self.0.de.0.sig_parser.clone();
473 // Skip key signature (always 1 char)
474 sig_parser.skip_char()?;
475 self.0.next(seed, sig_parser)
476 }
477 }
478
479 #[derive(Debug)]
480 struct StructureDeserializer<'d, 'de, 'sig, 'f, B> {
481 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
482 }
483
484 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for StructureDeserializer<'d, 'de, 'sig, 'f, B>
485 where
486 B: byteorder::ByteOrder,
487 {
488 type Error = Error;
489
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,490 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
491 where
492 T: DeserializeSeed<'de>,
493 {
494 let v = seed.deserialize(&mut *self.de).map(Some);
495
496 if self.de.0.sig_parser.next_char() == STRUCT_SIG_END_CHAR {
497 // Last item in the struct
498 self.de.0.sig_parser.skip_char()?;
499 }
500
501 v
502 }
503 }
504
505 #[derive(Debug)]
506 struct ValueDeserializer<'d, 'de, 'sig, 'f, B> {
507 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
508 stage: ValueParseStage,
509 sig_start: usize,
510 }
511
512 impl<'d, 'de, 'sig, 'f, B> ValueDeserializer<'d, 'de, 'sig, 'f, B>
513 where
514 B: byteorder::ByteOrder,
515 {
new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Self516 fn new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Self {
517 let sig_start = de.0.pos;
518 ValueDeserializer::<B> {
519 de,
520 stage: ValueParseStage::Signature,
521 sig_start,
522 }
523 }
524 }
525
526 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for ValueDeserializer<'d, 'de, 'sig, 'f, B>
527 where
528 B: byteorder::ByteOrder,
529 {
530 type Error = Error;
531
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,532 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
533 where
534 T: DeserializeSeed<'de>,
535 {
536 match self.stage {
537 ValueParseStage::Signature => {
538 self.stage = ValueParseStage::Value;
539
540 seed.deserialize(&mut *self.de).map(Some)
541 }
542 ValueParseStage::Value => {
543 self.stage = ValueParseStage::Done;
544
545 let sig_len = self.de.0.bytes[self.sig_start] as usize;
546 // skip length byte
547 let sig_start = self.sig_start + 1;
548 let sig_end = sig_start + sig_len;
549 // Skip trailing nul byte
550 let value_start = sig_end + 1;
551
552 let slice = &self.de.0.bytes[sig_start..sig_end];
553 // FIXME: Can we just use `Signature::from_bytes_unchecked`?
554 let signature = Signature::try_from(slice)?;
555 let sig_parser = SignatureParser::new(signature);
556
557 let ctxt = EncodingContext::new(
558 EncodingFormat::DBus,
559 self.de.0.ctxt.position() + value_start,
560 );
561 let mut de = Deserializer::<B>(crate::DeserializerCommon {
562 ctxt,
563 sig_parser,
564 bytes: &self.de.0.bytes[value_start..],
565 fds: self.de.0.fds,
566 pos: 0,
567 b: PhantomData,
568 });
569
570 let v = seed.deserialize(&mut de).map(Some);
571 self.de.0.pos += de.0.pos;
572
573 v
574 }
575 ValueParseStage::Done => Ok(None),
576 }
577 }
578 }
579
580 impl<'de, 'd, 'sig, 'f, B> crate::de::GetDeserializeCommon<'de, 'sig, 'f, B>
581 for &'d mut Deserializer<'de, 'sig, 'f, B>
582 where
583 B: byteorder::ByteOrder,
584 {
common_mut<'dr>(self) -> &'dr mut crate::de::DeserializerCommon<'de, 'sig, 'f, B> where Self: 'dr,585 fn common_mut<'dr>(self) -> &'dr mut crate::de::DeserializerCommon<'de, 'sig, 'f, B>
586 where
587 Self: 'dr,
588 {
589 &mut self.0
590 }
591 }
592
593 impl<'de, 'd, 'sig, 'f, B> EnumAccess<'de>
594 for crate::de::Enum<B, &'d mut Deserializer<'de, 'sig, 'f, B>>
595 where
596 B: byteorder::ByteOrder,
597 {
598 type Error = Error;
599 type Variant = Self;
600
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>,601 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
602 where
603 V: DeserializeSeed<'de>,
604 {
605 seed.deserialize(&mut *self.de).map(|v| (v, self))
606 }
607 }
608