1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Clone, Debug, PartialEq)]
12pub struct FramePresentedInfo {
13 pub actual_presentation_time: i64,
17 pub presentation_infos: Vec<PresentReceivedInfo>,
20 pub num_presents_allowed: u64,
22}
23
24impl fidl::Persistable for FramePresentedInfo {}
25
26#[derive(Clone, Debug, PartialEq)]
29pub struct FuturePresentationTimes {
30 pub future_presentations: Vec<PresentationInfo>,
37 pub remaining_presents_in_flight_allowed: i64,
44}
45
46impl fidl::Persistable for FuturePresentationTimes {}
47
48#[derive(Clone, Debug, Default, PartialEq)]
51pub struct PresentReceivedInfo {
52 pub present_received_time: Option<i64>,
54 pub latched_time: Option<i64>,
57 #[doc(hidden)]
58 pub __source_breaking: fidl::marker::SourceBreaking,
59}
60
61impl fidl::Persistable for PresentReceivedInfo {}
62
63#[derive(Clone, Debug, Default, PartialEq)]
66pub struct PresentationInfo {
67 pub latch_point: Option<i64>,
73 pub presentation_time: Option<i64>,
76 #[doc(hidden)]
77 pub __source_breaking: fidl::marker::SourceBreaking,
78}
79
80impl fidl::Persistable for PresentationInfo {}
81
82mod internal {
83 use super::*;
84
85 impl fidl::encoding::ValueTypeMarker for FramePresentedInfo {
86 type Borrowed<'a> = &'a Self;
87 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
88 value
89 }
90 }
91
92 unsafe impl fidl::encoding::TypeMarker for FramePresentedInfo {
93 type Owned = Self;
94
95 #[inline(always)]
96 fn inline_align(_context: fidl::encoding::Context) -> usize {
97 8
98 }
99
100 #[inline(always)]
101 fn inline_size(_context: fidl::encoding::Context) -> usize {
102 32
103 }
104 }
105
106 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FramePresentedInfo, D>
107 for &FramePresentedInfo
108 {
109 #[inline]
110 unsafe fn encode(
111 self,
112 encoder: &mut fidl::encoding::Encoder<'_, D>,
113 offset: usize,
114 _depth: fidl::encoding::Depth,
115 ) -> fidl::Result<()> {
116 encoder.debug_check_bounds::<FramePresentedInfo>(offset);
117 fidl::encoding::Encode::<FramePresentedInfo, D>::encode(
119 (
120 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.actual_presentation_time),
121 <fidl::encoding::Vector<PresentReceivedInfo, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.presentation_infos),
122 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.num_presents_allowed),
123 ),
124 encoder, offset, _depth
125 )
126 }
127 }
128 unsafe impl<
129 D: fidl::encoding::ResourceDialect,
130 T0: fidl::encoding::Encode<i64, D>,
131 T1: fidl::encoding::Encode<fidl::encoding::Vector<PresentReceivedInfo, 32>, D>,
132 T2: fidl::encoding::Encode<u64, D>,
133 > fidl::encoding::Encode<FramePresentedInfo, D> for (T0, T1, T2)
134 {
135 #[inline]
136 unsafe fn encode(
137 self,
138 encoder: &mut fidl::encoding::Encoder<'_, D>,
139 offset: usize,
140 depth: fidl::encoding::Depth,
141 ) -> fidl::Result<()> {
142 encoder.debug_check_bounds::<FramePresentedInfo>(offset);
143 self.0.encode(encoder, offset + 0, depth)?;
147 self.1.encode(encoder, offset + 8, depth)?;
148 self.2.encode(encoder, offset + 24, depth)?;
149 Ok(())
150 }
151 }
152
153 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FramePresentedInfo {
154 #[inline(always)]
155 fn new_empty() -> Self {
156 Self {
157 actual_presentation_time: fidl::new_empty!(i64, D),
158 presentation_infos: fidl::new_empty!(fidl::encoding::Vector<PresentReceivedInfo, 32>, D),
159 num_presents_allowed: fidl::new_empty!(u64, D),
160 }
161 }
162
163 #[inline]
164 unsafe fn decode(
165 &mut self,
166 decoder: &mut fidl::encoding::Decoder<'_, D>,
167 offset: usize,
168 _depth: fidl::encoding::Depth,
169 ) -> fidl::Result<()> {
170 decoder.debug_check_bounds::<Self>(offset);
171 fidl::decode!(i64, D, &mut self.actual_presentation_time, decoder, offset + 0, _depth)?;
173 fidl::decode!(fidl::encoding::Vector<PresentReceivedInfo, 32>, D, &mut self.presentation_infos, decoder, offset + 8, _depth)?;
174 fidl::decode!(u64, D, &mut self.num_presents_allowed, decoder, offset + 24, _depth)?;
175 Ok(())
176 }
177 }
178
179 impl fidl::encoding::ValueTypeMarker for FuturePresentationTimes {
180 type Borrowed<'a> = &'a Self;
181 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
182 value
183 }
184 }
185
186 unsafe impl fidl::encoding::TypeMarker for FuturePresentationTimes {
187 type Owned = Self;
188
189 #[inline(always)]
190 fn inline_align(_context: fidl::encoding::Context) -> usize {
191 8
192 }
193
194 #[inline(always)]
195 fn inline_size(_context: fidl::encoding::Context) -> usize {
196 24
197 }
198 }
199
200 unsafe impl<D: fidl::encoding::ResourceDialect>
201 fidl::encoding::Encode<FuturePresentationTimes, D> for &FuturePresentationTimes
202 {
203 #[inline]
204 unsafe fn encode(
205 self,
206 encoder: &mut fidl::encoding::Encoder<'_, D>,
207 offset: usize,
208 _depth: fidl::encoding::Depth,
209 ) -> fidl::Result<()> {
210 encoder.debug_check_bounds::<FuturePresentationTimes>(offset);
211 fidl::encoding::Encode::<FuturePresentationTimes, D>::encode(
213 (
214 <fidl::encoding::Vector<PresentationInfo, 8> as fidl::encoding::ValueTypeMarker>::borrow(&self.future_presentations),
215 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.remaining_presents_in_flight_allowed),
216 ),
217 encoder, offset, _depth
218 )
219 }
220 }
221 unsafe impl<
222 D: fidl::encoding::ResourceDialect,
223 T0: fidl::encoding::Encode<fidl::encoding::Vector<PresentationInfo, 8>, D>,
224 T1: fidl::encoding::Encode<i64, D>,
225 > fidl::encoding::Encode<FuturePresentationTimes, D> for (T0, T1)
226 {
227 #[inline]
228 unsafe fn encode(
229 self,
230 encoder: &mut fidl::encoding::Encoder<'_, D>,
231 offset: usize,
232 depth: fidl::encoding::Depth,
233 ) -> fidl::Result<()> {
234 encoder.debug_check_bounds::<FuturePresentationTimes>(offset);
235 self.0.encode(encoder, offset + 0, depth)?;
239 self.1.encode(encoder, offset + 16, depth)?;
240 Ok(())
241 }
242 }
243
244 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
245 for FuturePresentationTimes
246 {
247 #[inline(always)]
248 fn new_empty() -> Self {
249 Self {
250 future_presentations: fidl::new_empty!(fidl::encoding::Vector<PresentationInfo, 8>, D),
251 remaining_presents_in_flight_allowed: fidl::new_empty!(i64, D),
252 }
253 }
254
255 #[inline]
256 unsafe fn decode(
257 &mut self,
258 decoder: &mut fidl::encoding::Decoder<'_, D>,
259 offset: usize,
260 _depth: fidl::encoding::Depth,
261 ) -> fidl::Result<()> {
262 decoder.debug_check_bounds::<Self>(offset);
263 fidl::decode!(fidl::encoding::Vector<PresentationInfo, 8>, D, &mut self.future_presentations, decoder, offset + 0, _depth)?;
265 fidl::decode!(
266 i64,
267 D,
268 &mut self.remaining_presents_in_flight_allowed,
269 decoder,
270 offset + 16,
271 _depth
272 )?;
273 Ok(())
274 }
275 }
276
277 impl PresentReceivedInfo {
278 #[inline(always)]
279 fn max_ordinal_present(&self) -> u64 {
280 if let Some(_) = self.latched_time {
281 return 2;
282 }
283 if let Some(_) = self.present_received_time {
284 return 1;
285 }
286 0
287 }
288 }
289
290 impl fidl::encoding::ValueTypeMarker for PresentReceivedInfo {
291 type Borrowed<'a> = &'a Self;
292 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
293 value
294 }
295 }
296
297 unsafe impl fidl::encoding::TypeMarker for PresentReceivedInfo {
298 type Owned = Self;
299
300 #[inline(always)]
301 fn inline_align(_context: fidl::encoding::Context) -> usize {
302 8
303 }
304
305 #[inline(always)]
306 fn inline_size(_context: fidl::encoding::Context) -> usize {
307 16
308 }
309 }
310
311 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PresentReceivedInfo, D>
312 for &PresentReceivedInfo
313 {
314 unsafe fn encode(
315 self,
316 encoder: &mut fidl::encoding::Encoder<'_, D>,
317 offset: usize,
318 mut depth: fidl::encoding::Depth,
319 ) -> fidl::Result<()> {
320 encoder.debug_check_bounds::<PresentReceivedInfo>(offset);
321 let max_ordinal: u64 = self.max_ordinal_present();
323 encoder.write_num(max_ordinal, offset);
324 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
325 if max_ordinal == 0 {
327 return Ok(());
328 }
329 depth.increment()?;
330 let envelope_size = 8;
331 let bytes_len = max_ordinal as usize * envelope_size;
332 #[allow(unused_variables)]
333 let offset = encoder.out_of_line_offset(bytes_len);
334 let mut _prev_end_offset: usize = 0;
335 if 1 > max_ordinal {
336 return Ok(());
337 }
338
339 let cur_offset: usize = (1 - 1) * envelope_size;
342
343 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
345
346 fidl::encoding::encode_in_envelope_optional::<i64, D>(
351 self.present_received_time
352 .as_ref()
353 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
354 encoder,
355 offset + cur_offset,
356 depth,
357 )?;
358
359 _prev_end_offset = cur_offset + envelope_size;
360 if 2 > max_ordinal {
361 return Ok(());
362 }
363
364 let cur_offset: usize = (2 - 1) * envelope_size;
367
368 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
370
371 fidl::encoding::encode_in_envelope_optional::<i64, D>(
376 self.latched_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
377 encoder,
378 offset + cur_offset,
379 depth,
380 )?;
381
382 _prev_end_offset = cur_offset + envelope_size;
383
384 Ok(())
385 }
386 }
387
388 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PresentReceivedInfo {
389 #[inline(always)]
390 fn new_empty() -> Self {
391 Self::default()
392 }
393
394 unsafe fn decode(
395 &mut self,
396 decoder: &mut fidl::encoding::Decoder<'_, D>,
397 offset: usize,
398 mut depth: fidl::encoding::Depth,
399 ) -> fidl::Result<()> {
400 decoder.debug_check_bounds::<Self>(offset);
401 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
402 None => return Err(fidl::Error::NotNullable),
403 Some(len) => len,
404 };
405 if len == 0 {
407 return Ok(());
408 };
409 depth.increment()?;
410 let envelope_size = 8;
411 let bytes_len = len * envelope_size;
412 let offset = decoder.out_of_line_offset(bytes_len)?;
413 let mut _next_ordinal_to_read = 0;
415 let mut next_offset = offset;
416 let end_offset = offset + bytes_len;
417 _next_ordinal_to_read += 1;
418 if next_offset >= end_offset {
419 return Ok(());
420 }
421
422 while _next_ordinal_to_read < 1 {
424 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
425 _next_ordinal_to_read += 1;
426 next_offset += envelope_size;
427 }
428
429 let next_out_of_line = decoder.next_out_of_line();
430 let handles_before = decoder.remaining_handles();
431 if let Some((inlined, num_bytes, num_handles)) =
432 fidl::encoding::decode_envelope_header(decoder, next_offset)?
433 {
434 let member_inline_size =
435 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
436 if inlined != (member_inline_size <= 4) {
437 return Err(fidl::Error::InvalidInlineBitInEnvelope);
438 }
439 let inner_offset;
440 let mut inner_depth = depth.clone();
441 if inlined {
442 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
443 inner_offset = next_offset;
444 } else {
445 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
446 inner_depth.increment()?;
447 }
448 let val_ref =
449 self.present_received_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
450 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
451 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
452 {
453 return Err(fidl::Error::InvalidNumBytesInEnvelope);
454 }
455 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
456 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
457 }
458 }
459
460 next_offset += envelope_size;
461 _next_ordinal_to_read += 1;
462 if next_offset >= end_offset {
463 return Ok(());
464 }
465
466 while _next_ordinal_to_read < 2 {
468 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
469 _next_ordinal_to_read += 1;
470 next_offset += envelope_size;
471 }
472
473 let next_out_of_line = decoder.next_out_of_line();
474 let handles_before = decoder.remaining_handles();
475 if let Some((inlined, num_bytes, num_handles)) =
476 fidl::encoding::decode_envelope_header(decoder, next_offset)?
477 {
478 let member_inline_size =
479 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
480 if inlined != (member_inline_size <= 4) {
481 return Err(fidl::Error::InvalidInlineBitInEnvelope);
482 }
483 let inner_offset;
484 let mut inner_depth = depth.clone();
485 if inlined {
486 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
487 inner_offset = next_offset;
488 } else {
489 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
490 inner_depth.increment()?;
491 }
492 let val_ref = self.latched_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
493 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
494 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
495 {
496 return Err(fidl::Error::InvalidNumBytesInEnvelope);
497 }
498 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
499 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
500 }
501 }
502
503 next_offset += envelope_size;
504
505 while next_offset < end_offset {
507 _next_ordinal_to_read += 1;
508 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
509 next_offset += envelope_size;
510 }
511
512 Ok(())
513 }
514 }
515
516 impl PresentationInfo {
517 #[inline(always)]
518 fn max_ordinal_present(&self) -> u64 {
519 if let Some(_) = self.presentation_time {
520 return 2;
521 }
522 if let Some(_) = self.latch_point {
523 return 1;
524 }
525 0
526 }
527 }
528
529 impl fidl::encoding::ValueTypeMarker for PresentationInfo {
530 type Borrowed<'a> = &'a Self;
531 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
532 value
533 }
534 }
535
536 unsafe impl fidl::encoding::TypeMarker for PresentationInfo {
537 type Owned = Self;
538
539 #[inline(always)]
540 fn inline_align(_context: fidl::encoding::Context) -> usize {
541 8
542 }
543
544 #[inline(always)]
545 fn inline_size(_context: fidl::encoding::Context) -> usize {
546 16
547 }
548 }
549
550 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PresentationInfo, D>
551 for &PresentationInfo
552 {
553 unsafe fn encode(
554 self,
555 encoder: &mut fidl::encoding::Encoder<'_, D>,
556 offset: usize,
557 mut depth: fidl::encoding::Depth,
558 ) -> fidl::Result<()> {
559 encoder.debug_check_bounds::<PresentationInfo>(offset);
560 let max_ordinal: u64 = self.max_ordinal_present();
562 encoder.write_num(max_ordinal, offset);
563 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
564 if max_ordinal == 0 {
566 return Ok(());
567 }
568 depth.increment()?;
569 let envelope_size = 8;
570 let bytes_len = max_ordinal as usize * envelope_size;
571 #[allow(unused_variables)]
572 let offset = encoder.out_of_line_offset(bytes_len);
573 let mut _prev_end_offset: usize = 0;
574 if 1 > max_ordinal {
575 return Ok(());
576 }
577
578 let cur_offset: usize = (1 - 1) * envelope_size;
581
582 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
584
585 fidl::encoding::encode_in_envelope_optional::<i64, D>(
590 self.latch_point.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
591 encoder,
592 offset + cur_offset,
593 depth,
594 )?;
595
596 _prev_end_offset = cur_offset + envelope_size;
597 if 2 > max_ordinal {
598 return Ok(());
599 }
600
601 let cur_offset: usize = (2 - 1) * envelope_size;
604
605 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
607
608 fidl::encoding::encode_in_envelope_optional::<i64, D>(
613 self.presentation_time
614 .as_ref()
615 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
616 encoder,
617 offset + cur_offset,
618 depth,
619 )?;
620
621 _prev_end_offset = cur_offset + envelope_size;
622
623 Ok(())
624 }
625 }
626
627 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PresentationInfo {
628 #[inline(always)]
629 fn new_empty() -> Self {
630 Self::default()
631 }
632
633 unsafe fn decode(
634 &mut self,
635 decoder: &mut fidl::encoding::Decoder<'_, D>,
636 offset: usize,
637 mut depth: fidl::encoding::Depth,
638 ) -> fidl::Result<()> {
639 decoder.debug_check_bounds::<Self>(offset);
640 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
641 None => return Err(fidl::Error::NotNullable),
642 Some(len) => len,
643 };
644 if len == 0 {
646 return Ok(());
647 };
648 depth.increment()?;
649 let envelope_size = 8;
650 let bytes_len = len * envelope_size;
651 let offset = decoder.out_of_line_offset(bytes_len)?;
652 let mut _next_ordinal_to_read = 0;
654 let mut next_offset = offset;
655 let end_offset = offset + bytes_len;
656 _next_ordinal_to_read += 1;
657 if next_offset >= end_offset {
658 return Ok(());
659 }
660
661 while _next_ordinal_to_read < 1 {
663 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
664 _next_ordinal_to_read += 1;
665 next_offset += envelope_size;
666 }
667
668 let next_out_of_line = decoder.next_out_of_line();
669 let handles_before = decoder.remaining_handles();
670 if let Some((inlined, num_bytes, num_handles)) =
671 fidl::encoding::decode_envelope_header(decoder, next_offset)?
672 {
673 let member_inline_size =
674 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
675 if inlined != (member_inline_size <= 4) {
676 return Err(fidl::Error::InvalidInlineBitInEnvelope);
677 }
678 let inner_offset;
679 let mut inner_depth = depth.clone();
680 if inlined {
681 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
682 inner_offset = next_offset;
683 } else {
684 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
685 inner_depth.increment()?;
686 }
687 let val_ref = self.latch_point.get_or_insert_with(|| fidl::new_empty!(i64, D));
688 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
689 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
690 {
691 return Err(fidl::Error::InvalidNumBytesInEnvelope);
692 }
693 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
694 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
695 }
696 }
697
698 next_offset += envelope_size;
699 _next_ordinal_to_read += 1;
700 if next_offset >= end_offset {
701 return Ok(());
702 }
703
704 while _next_ordinal_to_read < 2 {
706 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
707 _next_ordinal_to_read += 1;
708 next_offset += envelope_size;
709 }
710
711 let next_out_of_line = decoder.next_out_of_line();
712 let handles_before = decoder.remaining_handles();
713 if let Some((inlined, num_bytes, num_handles)) =
714 fidl::encoding::decode_envelope_header(decoder, next_offset)?
715 {
716 let member_inline_size =
717 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
718 if inlined != (member_inline_size <= 4) {
719 return Err(fidl::Error::InvalidInlineBitInEnvelope);
720 }
721 let inner_offset;
722 let mut inner_depth = depth.clone();
723 if inlined {
724 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
725 inner_offset = next_offset;
726 } else {
727 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
728 inner_depth.increment()?;
729 }
730 let val_ref =
731 self.presentation_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
732 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
733 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
734 {
735 return Err(fidl::Error::InvalidNumBytesInEnvelope);
736 }
737 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
738 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
739 }
740 }
741
742 next_offset += envelope_size;
743
744 while next_offset < end_offset {
746 _next_ordinal_to_read += 1;
747 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
748 next_offset += envelope_size;
749 }
750
751 Ok(())
752 }
753 }
754}