1mod bytes;
2mod enum_;
3mod map;
4mod set;
5mod struct_;
6mod vec;
7
8use crate::buf_ext::ValueBufExt;
9use crate::tags::{self, KeyTag, Tag};
10use crate::{
11 ChannelCookie, Deserialize, DeserializeError, DeserializeKey, ObjectCookie, ObjectId,
12 ObjectUuid, SerializedValueSlice, ServiceCookie, ServiceId, ServiceUuid, ValueKind,
13 MAX_VALUE_DEPTH,
14};
15use ::bytes::Buf;
16use uuid::Uuid;
17
18pub use self::bytes::{Bytes1Deserializer, Bytes2Deserializer, BytesDeserializer};
19pub use enum_::EnumDeserializer;
20pub use map::{Map1Deserializer, Map2Deserializer, MapDeserializer, MapElementDeserializer};
21pub use set::{Set1Deserializer, Set2Deserializer, SetDeserializer};
22pub use struct_::{
23 FieldDeserializer, Struct1Deserializer, Struct2Deserializer, StructDeserializer,
24};
25pub use vec::{Vec1Deserializer, Vec2Deserializer, VecDeserializer};
26
27#[derive(Debug)]
28pub struct Deserializer<'a, 'b> {
29 buf: &'a mut &'b [u8],
30 depth: u8,
31}
32
33impl<'a, 'b> Deserializer<'a, 'b> {
34 pub(crate) fn new(buf: &'a mut &'b [u8], depth: u8) -> Result<Self, DeserializeError> {
35 let mut this = Self { buf, depth };
36 this.increment_depth()?;
37 Ok(this)
38 }
39
40 fn increment_depth(&mut self) -> Result<(), DeserializeError> {
41 self.depth += 1;
42 if self.depth <= MAX_VALUE_DEPTH {
43 Ok(())
44 } else {
45 Err(DeserializeError::TooDeeplyNested)
46 }
47 }
48
49 #[allow(clippy::len_without_is_empty)]
50 pub fn len(&self) -> Result<usize, DeserializeError> {
51 let mut buf = *self.buf;
52 Deserializer::new(&mut buf, self.depth - 1)?.skip()?;
53
54 Ok(buf.as_ptr() as usize - (*self.buf).as_ptr() as usize)
57 }
58
59 pub fn split_off_serialized_value(self) -> Result<&'b SerializedValueSlice, DeserializeError> {
60 let len = self.len()?;
61 let res = SerializedValueSlice::new(&self.buf[..len]);
62 self.buf.advance(len);
63 Ok(res)
64 }
65
66 pub fn peek_value_kind(&self) -> Result<ValueKind, DeserializeError> {
67 self.buf.try_peek_discriminant_u8()
68 }
69
70 pub fn skip(mut self) -> Result<(), DeserializeError> {
71 match self.buf.try_get_discriminant_u8()? {
72 ValueKind::None => Ok(()),
73
74 ValueKind::Some => {
75 self.increment_depth()?;
76 self.skip()
77 }
78
79 ValueKind::Bool | ValueKind::U8 | ValueKind::I8 => self.buf.try_skip(1),
80 ValueKind::U16 | ValueKind::I16 => self.buf.try_skip_varint_le::<2>(),
81 ValueKind::U32 | ValueKind::I32 => self.buf.try_skip_varint_le::<4>(),
82 ValueKind::U64 | ValueKind::I64 => self.buf.try_skip_varint_le::<8>(),
83 ValueKind::F32 => self.buf.try_skip(4),
84 ValueKind::F64 => self.buf.try_skip(8),
85
86 ValueKind::String => {
87 let len = self.buf.try_get_varint_u32_le()? as usize;
88 self.buf.try_skip(len)
89 }
90
91 ValueKind::Uuid | ValueKind::Sender | ValueKind::Receiver => self.buf.try_skip(16),
92 ValueKind::ObjectId => self.buf.try_skip(32),
93 ValueKind::ServiceId => self.buf.try_skip(64),
94
95 ValueKind::Vec1 => {
96 Vec1Deserializer::new_without_value_kind(self.buf, self.depth)?.skip()
97 }
98
99 ValueKind::Bytes1 => Bytes1Deserializer::new_without_value_kind(self.buf)?.skip(),
100
101 ValueKind::U8Map1 => {
102 Map1Deserializer::<tags::U8>::new_without_value_kind(self.buf, self.depth)?.skip()
103 }
104
105 ValueKind::I8Map1 => {
106 Map1Deserializer::<tags::I8>::new_without_value_kind(self.buf, self.depth)?.skip()
107 }
108
109 ValueKind::U16Map1 => {
110 Map1Deserializer::<tags::U16>::new_without_value_kind(self.buf, self.depth)?.skip()
111 }
112
113 ValueKind::I16Map1 => {
114 Map1Deserializer::<tags::I16>::new_without_value_kind(self.buf, self.depth)?.skip()
115 }
116
117 ValueKind::U32Map1 => {
118 Map1Deserializer::<tags::U32>::new_without_value_kind(self.buf, self.depth)?.skip()
119 }
120
121 ValueKind::I32Map1 => {
122 Map1Deserializer::<tags::I32>::new_without_value_kind(self.buf, self.depth)?.skip()
123 }
124
125 ValueKind::U64Map1 => {
126 Map1Deserializer::<tags::U64>::new_without_value_kind(self.buf, self.depth)?.skip()
127 }
128
129 ValueKind::I64Map1 => {
130 Map1Deserializer::<tags::I64>::new_without_value_kind(self.buf, self.depth)?.skip()
131 }
132
133 ValueKind::StringMap1 => {
134 Map1Deserializer::<tags::String>::new_without_value_kind(self.buf, self.depth)?
135 .skip()
136 }
137
138 ValueKind::UuidMap1 => {
139 Map1Deserializer::<tags::Uuid>::new_without_value_kind(self.buf, self.depth)?.skip()
140 }
141
142 ValueKind::U8Set1 => {
143 Set1Deserializer::<tags::U8>::new_without_value_kind(self.buf)?.skip()
144 }
145
146 ValueKind::I8Set1 => {
147 Set1Deserializer::<tags::I8>::new_without_value_kind(self.buf)?.skip()
148 }
149
150 ValueKind::U16Set1 => {
151 Set1Deserializer::<tags::U16>::new_without_value_kind(self.buf)?.skip()
152 }
153
154 ValueKind::I16Set1 => {
155 Set1Deserializer::<tags::I16>::new_without_value_kind(self.buf)?.skip()
156 }
157
158 ValueKind::U32Set1 => {
159 Set1Deserializer::<tags::U32>::new_without_value_kind(self.buf)?.skip()
160 }
161
162 ValueKind::I32Set1 => {
163 Set1Deserializer::<tags::I32>::new_without_value_kind(self.buf)?.skip()
164 }
165
166 ValueKind::U64Set1 => {
167 Set1Deserializer::<tags::U64>::new_without_value_kind(self.buf)?.skip()
168 }
169
170 ValueKind::I64Set1 => {
171 Set1Deserializer::<tags::I64>::new_without_value_kind(self.buf)?.skip()
172 }
173
174 ValueKind::StringSet1 => {
175 Set1Deserializer::<tags::String>::new_without_value_kind(self.buf)?.skip()
176 }
177
178 ValueKind::UuidSet1 => {
179 Set1Deserializer::<tags::Uuid>::new_without_value_kind(self.buf)?.skip()
180 }
181
182 ValueKind::Struct1 => {
183 Struct1Deserializer::new_without_value_kind(self.buf, self.depth)?.skip()
184 }
185
186 ValueKind::Enum => {
187 EnumDeserializer::new_without_value_kind(self.buf, self.depth)?.skip()
188 }
189
190 ValueKind::Vec2 => {
191 Vec2Deserializer::new_without_value_kind(self.buf, self.depth)?.skip()
192 }
193
194 ValueKind::Bytes2 => Bytes2Deserializer::new_without_value_kind(self.buf)?.skip(),
195
196 ValueKind::U8Map2 => {
197 Map2Deserializer::<tags::U8>::new_without_value_kind(self.buf, self.depth)?.skip()
198 }
199
200 ValueKind::I8Map2 => {
201 Map2Deserializer::<tags::I8>::new_without_value_kind(self.buf, self.depth)?.skip()
202 }
203
204 ValueKind::U16Map2 => {
205 Map2Deserializer::<tags::U16>::new_without_value_kind(self.buf, self.depth)?.skip()
206 }
207
208 ValueKind::I16Map2 => {
209 Map2Deserializer::<tags::I16>::new_without_value_kind(self.buf, self.depth)?.skip()
210 }
211
212 ValueKind::U32Map2 => {
213 Map2Deserializer::<tags::U32>::new_without_value_kind(self.buf, self.depth)?.skip()
214 }
215
216 ValueKind::I32Map2 => {
217 Map2Deserializer::<tags::I32>::new_without_value_kind(self.buf, self.depth)?.skip()
218 }
219
220 ValueKind::U64Map2 => {
221 Map2Deserializer::<tags::U64>::new_without_value_kind(self.buf, self.depth)?.skip()
222 }
223
224 ValueKind::I64Map2 => {
225 Map2Deserializer::<tags::I64>::new_without_value_kind(self.buf, self.depth)?.skip()
226 }
227
228 ValueKind::StringMap2 => {
229 Map2Deserializer::<tags::String>::new_without_value_kind(self.buf, self.depth)?
230 .skip()
231 }
232
233 ValueKind::UuidMap2 => {
234 Map2Deserializer::<tags::Uuid>::new_without_value_kind(self.buf, self.depth)?.skip()
235 }
236
237 ValueKind::U8Set2 => {
238 Set2Deserializer::<tags::U8>::new_without_value_kind(self.buf)?.skip()
239 }
240
241 ValueKind::I8Set2 => {
242 Set2Deserializer::<tags::I8>::new_without_value_kind(self.buf)?.skip()
243 }
244
245 ValueKind::U16Set2 => {
246 Set2Deserializer::<tags::U16>::new_without_value_kind(self.buf)?.skip()
247 }
248
249 ValueKind::I16Set2 => {
250 Set2Deserializer::<tags::I16>::new_without_value_kind(self.buf)?.skip()
251 }
252
253 ValueKind::U32Set2 => {
254 Set2Deserializer::<tags::U32>::new_without_value_kind(self.buf)?.skip()
255 }
256
257 ValueKind::I32Set2 => {
258 Set2Deserializer::<tags::I32>::new_without_value_kind(self.buf)?.skip()
259 }
260
261 ValueKind::U64Set2 => {
262 Set2Deserializer::<tags::U64>::new_without_value_kind(self.buf)?.skip()
263 }
264
265 ValueKind::I64Set2 => {
266 Set2Deserializer::<tags::I64>::new_without_value_kind(self.buf)?.skip()
267 }
268
269 ValueKind::StringSet2 => {
270 Set2Deserializer::<tags::String>::new_without_value_kind(self.buf)?.skip()
271 }
272
273 ValueKind::UuidSet2 => {
274 Set2Deserializer::<tags::Uuid>::new_without_value_kind(self.buf)?.skip()
275 }
276
277 ValueKind::Struct2 => {
278 Struct2Deserializer::new_without_value_kind(self.buf, self.depth)?.skip()
279 }
280 }
281 }
282
283 pub fn deserialize<T: Tag, U: Deserialize<T>>(self) -> Result<U, DeserializeError> {
284 U::deserialize(self)
285 }
286
287 pub fn deserialize_none(self) -> Result<(), DeserializeError> {
288 self.buf.ensure_discriminant_u8(ValueKind::None)
289 }
290
291 pub fn deserialize_some<T: Tag, U: Deserialize<T>>(mut self) -> Result<U, DeserializeError> {
292 self.increment_depth()?;
293 self.buf.ensure_discriminant_u8(ValueKind::Some)?;
294 self.deserialize()
295 }
296
297 pub fn deserialize_option<T: Tag, U: Deserialize<T>>(
298 mut self,
299 ) -> Result<Option<U>, DeserializeError> {
300 match self.buf.try_get_discriminant_u8()? {
301 ValueKind::Some => {
302 self.increment_depth()?;
303 self.deserialize().map(Some)
304 }
305
306 ValueKind::None => Ok(None),
307 _ => Err(DeserializeError::UnexpectedValue),
308 }
309 }
310
311 pub fn deserialize_bool(self) -> Result<bool, DeserializeError> {
312 self.buf.ensure_discriminant_u8(ValueKind::Bool)?;
313
314 self.buf
315 .try_get_u8()
316 .map(|v| v != 0)
317 .map_err(|_| DeserializeError::UnexpectedEoi)
318 }
319
320 pub fn deserialize_u8(self) -> Result<u8, DeserializeError> {
321 self.buf.ensure_discriminant_u8(ValueKind::U8)?;
322
323 self.buf
324 .try_get_u8()
325 .map_err(|_| DeserializeError::UnexpectedEoi)
326 }
327
328 pub fn deserialize_i8(self) -> Result<i8, DeserializeError> {
329 self.buf.ensure_discriminant_u8(ValueKind::I8)?;
330
331 self.buf
332 .try_get_i8()
333 .map_err(|_| DeserializeError::UnexpectedEoi)
334 }
335
336 pub fn deserialize_u16(self) -> Result<u16, DeserializeError> {
337 self.buf.ensure_discriminant_u8(ValueKind::U16)?;
338 self.buf.try_get_varint_u16_le()
339 }
340
341 pub fn deserialize_i16(self) -> Result<i16, DeserializeError> {
342 self.buf.ensure_discriminant_u8(ValueKind::I16)?;
343 self.buf.try_get_varint_i16_le()
344 }
345
346 pub fn deserialize_u32(self) -> Result<u32, DeserializeError> {
347 self.buf.ensure_discriminant_u8(ValueKind::U32)?;
348 self.buf.try_get_varint_u32_le()
349 }
350
351 pub fn deserialize_i32(self) -> Result<i32, DeserializeError> {
352 self.buf.ensure_discriminant_u8(ValueKind::I32)?;
353 self.buf.try_get_varint_i32_le()
354 }
355
356 pub fn deserialize_u64(self) -> Result<u64, DeserializeError> {
357 self.buf.ensure_discriminant_u8(ValueKind::U64)?;
358 self.buf.try_get_varint_u64_le()
359 }
360
361 pub fn deserialize_i64(self) -> Result<i64, DeserializeError> {
362 self.buf.ensure_discriminant_u8(ValueKind::I64)?;
363 self.buf.try_get_varint_i64_le()
364 }
365
366 pub fn deserialize_f32(self) -> Result<f32, DeserializeError> {
367 self.buf.ensure_discriminant_u8(ValueKind::F32)?;
368
369 self.buf
370 .try_get_f32_le()
371 .map_err(|_| DeserializeError::UnexpectedEoi)
372 }
373
374 pub fn deserialize_f64(self) -> Result<f64, DeserializeError> {
375 self.buf.ensure_discriminant_u8(ValueKind::F64)?;
376
377 self.buf
378 .try_get_f64_le()
379 .map_err(|_| DeserializeError::UnexpectedEoi)
380 }
381
382 pub fn deserialize_string(self) -> Result<String, DeserializeError> {
383 self.buf.ensure_discriminant_u8(ValueKind::String)?;
384 let len = self.buf.try_get_varint_u32_le()? as usize;
385 let bytes = self.buf.try_copy_to_bytes(len)?.into();
386 String::from_utf8(bytes).map_err(|_| DeserializeError::InvalidSerialization)
387 }
388
389 pub fn deserialize_uuid(self) -> Result<Uuid, DeserializeError> {
390 self.buf.ensure_discriminant_u8(ValueKind::Uuid)?;
391 let mut bytes = uuid::Bytes::default();
392
393 self.buf
394 .try_copy_to_slice(&mut bytes)
395 .map_err(|_| DeserializeError::UnexpectedEoi)?;
396
397 Ok(Uuid::from_bytes(bytes))
398 }
399
400 pub fn deserialize_object_id(self) -> Result<ObjectId, DeserializeError> {
401 self.buf.ensure_discriminant_u8(ValueKind::ObjectId)?;
402 let mut bytes = uuid::Bytes::default();
403
404 self.buf
405 .try_copy_to_slice(&mut bytes)
406 .map_err(|_| DeserializeError::UnexpectedEoi)?;
407 let uuid = ObjectUuid(Uuid::from_bytes(bytes));
408
409 self.buf
410 .try_copy_to_slice(&mut bytes)
411 .map_err(|_| DeserializeError::UnexpectedEoi)?;
412 let cookie = ObjectCookie(Uuid::from_bytes(bytes));
413
414 Ok(ObjectId::new(uuid, cookie))
415 }
416
417 pub fn deserialize_service_id(self) -> Result<ServiceId, DeserializeError> {
418 self.buf.ensure_discriminant_u8(ValueKind::ServiceId)?;
419 let mut bytes = uuid::Bytes::default();
420
421 self.buf
422 .try_copy_to_slice(&mut bytes)
423 .map_err(|_| DeserializeError::UnexpectedEoi)?;
424 let object_uuid = ObjectUuid(Uuid::from_bytes(bytes));
425
426 self.buf
427 .try_copy_to_slice(&mut bytes)
428 .map_err(|_| DeserializeError::UnexpectedEoi)?;
429 let object_cookie = ObjectCookie(Uuid::from_bytes(bytes));
430
431 self.buf
432 .try_copy_to_slice(&mut bytes)
433 .map_err(|_| DeserializeError::UnexpectedEoi)?;
434 let service_uuid = ServiceUuid(Uuid::from_bytes(bytes));
435
436 self.buf
437 .try_copy_to_slice(&mut bytes)
438 .map_err(|_| DeserializeError::UnexpectedEoi)?;
439 let service_cookie = ServiceCookie(Uuid::from_bytes(bytes));
440
441 Ok(ServiceId::new(
442 ObjectId::new(object_uuid, object_cookie),
443 service_uuid,
444 service_cookie,
445 ))
446 }
447
448 pub fn deserialize_vec(self) -> Result<VecDeserializer<'a, 'b>, DeserializeError> {
449 VecDeserializer::new(self.buf, self.depth)
450 }
451
452 pub fn deserialize_vec_extend<T, U, V>(self, vec: &mut V) -> Result<(), DeserializeError>
453 where
454 T: Tag,
455 U: Deserialize<T>,
456 V: Extend<U>,
457 {
458 self.deserialize_vec()?.deserialize_extend(vec)
459 }
460
461 pub fn deserialize_vec_extend_new<T, U, V>(self) -> Result<V, DeserializeError>
462 where
463 T: Tag,
464 U: Deserialize<T>,
465 V: Default + Extend<U>,
466 {
467 let mut vec = V::default();
468 self.deserialize_vec_extend(&mut vec)?;
469 Ok(vec)
470 }
471
472 pub fn deserialize_vec1(self) -> Result<Vec1Deserializer<'a, 'b>, DeserializeError> {
473 Vec1Deserializer::new(self.buf, self.depth)
474 }
475
476 pub fn deserialize_vec1_extend<T, U, V>(self, vec: &mut V) -> Result<(), DeserializeError>
477 where
478 T: Tag,
479 U: Deserialize<T>,
480 V: Extend<U>,
481 {
482 self.deserialize_vec1()?.deserialize_extend(vec)
483 }
484
485 pub fn deserialize_vec1_extend_new<T, U, V>(self) -> Result<V, DeserializeError>
486 where
487 T: Tag,
488 U: Deserialize<T>,
489 V: Default + Extend<U>,
490 {
491 let mut vec = V::default();
492 self.deserialize_vec1_extend(&mut vec)?;
493 Ok(vec)
494 }
495
496 pub fn deserialize_vec2(self) -> Result<Vec2Deserializer<'a, 'b>, DeserializeError> {
497 Vec2Deserializer::new(self.buf, self.depth)
498 }
499
500 pub fn deserialize_vec2_extend<T, U, V>(self, vec: &mut V) -> Result<(), DeserializeError>
501 where
502 T: Tag,
503 U: Deserialize<T>,
504 V: Extend<U>,
505 {
506 self.deserialize_vec2()?.deserialize_extend(vec)
507 }
508
509 pub fn deserialize_vec2_extend_new<T, U, V>(self) -> Result<V, DeserializeError>
510 where
511 T: Tag,
512 U: Deserialize<T>,
513 V: Default + Extend<U>,
514 {
515 let mut vec = V::default();
516 self.deserialize_vec2_extend(&mut vec)?;
517 Ok(vec)
518 }
519
520 pub fn deserialize_bytes(self) -> Result<BytesDeserializer<'a, 'b>, DeserializeError> {
521 BytesDeserializer::new(self.buf)
522 }
523
524 pub fn deserialize_bytes_extend<T>(self, bytes: &mut T) -> Result<(), DeserializeError>
525 where
526 T: Extend<u8>,
527 {
528 self.deserialize_bytes()?.deserialize_extend(bytes)
529 }
530
531 pub fn deserialize_bytes_extend_new<T>(self) -> Result<T, DeserializeError>
532 where
533 T: Default + Extend<u8>,
534 {
535 let mut bytes = T::default();
536 self.deserialize_bytes()?.deserialize_extend(&mut bytes)?;
537 Ok(bytes)
538 }
539
540 pub fn deserialize_bytes1(self) -> Result<Bytes1Deserializer<'a, 'b>, DeserializeError> {
541 Bytes1Deserializer::new(self.buf)
542 }
543
544 pub fn deserialize_bytes1_extend<T>(self, bytes: &mut T) -> Result<(), DeserializeError>
545 where
546 T: Extend<u8>,
547 {
548 self.deserialize_bytes1()?.deserialize_extend(bytes)
549 }
550
551 pub fn deserialize_bytes1_extend_new<T>(self) -> Result<T, DeserializeError>
552 where
553 T: Default + Extend<u8>,
554 {
555 let mut bytes = T::default();
556 self.deserialize_bytes1()?.deserialize_extend(&mut bytes)?;
557 Ok(bytes)
558 }
559
560 pub fn deserialize_bytes2(self) -> Result<Bytes2Deserializer<'a, 'b>, DeserializeError> {
561 Bytes2Deserializer::new(self.buf)
562 }
563
564 pub fn deserialize_bytes2_extend<T>(self, bytes: &mut T) -> Result<(), DeserializeError>
565 where
566 T: Extend<u8>,
567 {
568 self.deserialize_bytes2()?.deserialize_extend(bytes)
569 }
570
571 pub fn deserialize_bytes2_extend_new<T>(self) -> Result<T, DeserializeError>
572 where
573 T: Default + Extend<u8>,
574 {
575 let mut bytes = T::default();
576 self.deserialize_bytes2()?.deserialize_extend(&mut bytes)?;
577 Ok(bytes)
578 }
579
580 pub fn deserialize_map<K: KeyTag>(
581 self,
582 ) -> Result<MapDeserializer<'a, 'b, K>, DeserializeError> {
583 MapDeserializer::new(self.buf, self.depth)
584 }
585
586 pub fn deserialize_map_extend<K, L, T, U, V>(self, map: &mut V) -> Result<(), DeserializeError>
587 where
588 K: KeyTag,
589 L: DeserializeKey<K>,
590 T: Tag,
591 U: Deserialize<T>,
592 V: Extend<(L, U)>,
593 {
594 MapDeserializer::new(self.buf, self.depth)?.deserialize_extend(map)
595 }
596
597 pub fn deserialize_map_extend_new<K, L, T, U, V>(self) -> Result<V, DeserializeError>
598 where
599 K: KeyTag,
600 L: DeserializeKey<K>,
601 T: Tag,
602 U: Deserialize<T>,
603 V: Default + Extend<(L, U)>,
604 {
605 let mut map = V::default();
606 self.deserialize_map_extend(&mut map)?;
607 Ok(map)
608 }
609
610 pub fn deserialize_map1<K: KeyTag>(
611 self,
612 ) -> Result<Map1Deserializer<'a, 'b, K>, DeserializeError> {
613 Map1Deserializer::new(self.buf, self.depth)
614 }
615
616 pub fn deserialize_map1_extend<K, L, T, U, V>(self, map: &mut V) -> Result<(), DeserializeError>
617 where
618 K: KeyTag,
619 L: DeserializeKey<K>,
620 T: Tag,
621 U: Deserialize<T>,
622 V: Extend<(L, U)>,
623 {
624 Map1Deserializer::new(self.buf, self.depth)?.deserialize_extend(map)
625 }
626
627 pub fn deserialize_map1_extend_new<K, L, T, U, V>(self) -> Result<V, DeserializeError>
628 where
629 K: KeyTag,
630 L: DeserializeKey<K>,
631 T: Tag,
632 U: Deserialize<T>,
633 V: Default + Extend<(L, U)>,
634 {
635 let mut map = V::default();
636 self.deserialize_map1_extend(&mut map)?;
637 Ok(map)
638 }
639
640 pub fn deserialize_map2<K: KeyTag>(
641 self,
642 ) -> Result<Map2Deserializer<'a, 'b, K>, DeserializeError> {
643 Map2Deserializer::new(self.buf, self.depth)
644 }
645
646 pub fn deserialize_map2_extend<K, L, T, U, V>(self, map: &mut V) -> Result<(), DeserializeError>
647 where
648 K: KeyTag,
649 L: DeserializeKey<K>,
650 T: Tag,
651 U: Deserialize<T>,
652 V: Extend<(L, U)>,
653 {
654 Map2Deserializer::new(self.buf, self.depth)?.deserialize_extend(map)
655 }
656
657 pub fn deserialize_map2_extend_new<K, L, T, U, V>(self) -> Result<V, DeserializeError>
658 where
659 K: KeyTag,
660 L: DeserializeKey<K>,
661 T: Tag,
662 U: Deserialize<T>,
663 V: Default + Extend<(L, U)>,
664 {
665 let mut map = V::default();
666 self.deserialize_map2_extend(&mut map)?;
667 Ok(map)
668 }
669
670 pub fn deserialize_set<K: KeyTag>(
671 self,
672 ) -> Result<SetDeserializer<'a, 'b, K>, DeserializeError> {
673 SetDeserializer::new(self.buf)
674 }
675
676 pub fn deserialize_set_extend<K, T, U>(self, set: &mut U) -> Result<(), DeserializeError>
677 where
678 K: KeyTag,
679 T: DeserializeKey<K>,
680 U: Extend<T>,
681 {
682 self.deserialize_set()?.deserialize_extend(set)
683 }
684
685 pub fn deserialize_set_extend_new<K, T, U>(self) -> Result<U, DeserializeError>
686 where
687 K: KeyTag,
688 T: DeserializeKey<K>,
689 U: Default + Extend<T>,
690 {
691 let mut set = U::default();
692 self.deserialize_set_extend(&mut set)?;
693 Ok(set)
694 }
695
696 pub fn deserialize_set1<K: KeyTag>(
697 self,
698 ) -> Result<Set1Deserializer<'a, 'b, K>, DeserializeError> {
699 Set1Deserializer::new(self.buf)
700 }
701
702 pub fn deserialize_set1_extend<K, T, U>(self, set: &mut U) -> Result<(), DeserializeError>
703 where
704 K: KeyTag,
705 T: DeserializeKey<K>,
706 U: Extend<T>,
707 {
708 self.deserialize_set1()?.deserialize_extend(set)
709 }
710
711 pub fn deserialize_set1_extend_new<K, T, U>(self) -> Result<U, DeserializeError>
712 where
713 K: KeyTag,
714 T: DeserializeKey<K>,
715 U: Default + Extend<T>,
716 {
717 let mut set = U::default();
718 self.deserialize_set1_extend(&mut set)?;
719 Ok(set)
720 }
721
722 pub fn deserialize_set2<K: KeyTag>(
723 self,
724 ) -> Result<Set2Deserializer<'a, 'b, K>, DeserializeError> {
725 Set2Deserializer::new(self.buf)
726 }
727
728 pub fn deserialize_set2_extend<K, T, U>(self, set: &mut U) -> Result<(), DeserializeError>
729 where
730 K: KeyTag,
731 T: DeserializeKey<K>,
732 U: Extend<T>,
733 {
734 self.deserialize_set2()?.deserialize_extend(set)
735 }
736
737 pub fn deserialize_set2_extend_new<K, T, U>(self) -> Result<U, DeserializeError>
738 where
739 K: KeyTag,
740 T: DeserializeKey<K>,
741 U: Default + Extend<T>,
742 {
743 let mut set = U::default();
744 self.deserialize_set2_extend(&mut set)?;
745 Ok(set)
746 }
747
748 pub fn deserialize_struct(self) -> Result<StructDeserializer<'a, 'b>, DeserializeError> {
749 StructDeserializer::new(self.buf, self.depth)
750 }
751
752 pub fn deserialize_struct1(self) -> Result<Struct1Deserializer<'a, 'b>, DeserializeError> {
753 Struct1Deserializer::new(self.buf, self.depth)
754 }
755
756 pub fn deserialize_struct2(self) -> Result<Struct2Deserializer<'a, 'b>, DeserializeError> {
757 Struct2Deserializer::new(self.buf, self.depth)
758 }
759
760 pub fn deserialize_enum(self) -> Result<EnumDeserializer<'a, 'b>, DeserializeError> {
761 EnumDeserializer::new(self.buf, self.depth)
762 }
763
764 pub fn deserialize_sender(self) -> Result<ChannelCookie, DeserializeError> {
765 self.buf.ensure_discriminant_u8(ValueKind::Sender)?;
766 let mut bytes = uuid::Bytes::default();
767
768 self.buf
769 .try_copy_to_slice(&mut bytes)
770 .map_err(|_| DeserializeError::UnexpectedEoi)?;
771
772 Ok(ChannelCookie(Uuid::from_bytes(bytes)))
773 }
774
775 pub fn deserialize_receiver(self) -> Result<ChannelCookie, DeserializeError> {
776 self.buf.ensure_discriminant_u8(ValueKind::Receiver)?;
777 let mut bytes = uuid::Bytes::default();
778
779 self.buf
780 .try_copy_to_slice(&mut bytes)
781 .map_err(|_| DeserializeError::UnexpectedEoi)?;
782
783 Ok(ChannelCookie(Uuid::from_bytes(bytes)))
784 }
785}