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(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12#[repr(u32)]
13pub enum Status {
14 Active = 1,
15 Paused = 2,
16 Error = 3,
17 Cancelled = 4,
18 Complete = 5,
19}
20
21impl Status {
22 #[inline]
23 pub fn from_primitive(prim: u32) -> Option<Self> {
24 match prim {
25 1 => Some(Self::Active),
26 2 => Some(Self::Paused),
27 3 => Some(Self::Error),
28 4 => Some(Self::Cancelled),
29 5 => Some(Self::Complete),
30 _ => None,
31 }
32 }
33
34 #[inline]
35 pub const fn into_primitive(self) -> u32 {
36 self as u32
37 }
38}
39
40#[derive(Clone, Debug, PartialEq)]
41pub struct FactoryResetCountdownWatchResponse {
42 pub state: FactoryResetCountdownState,
43}
44
45impl fidl::Persistable for FactoryResetCountdownWatchResponse {}
46
47#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
48pub struct ProgressRendererRenderRequest {
49 pub status: Status,
50 pub percent_complete: f32,
51}
52
53impl fidl::Persistable for ProgressRendererRenderRequest {}
54
55#[derive(Clone, Debug, Default, PartialEq)]
58pub struct FactoryResetCountdownState {
59 pub scheduled_reset_time: Option<i64>,
63 #[doc(hidden)]
64 pub __source_breaking: fidl::marker::SourceBreaking,
65}
66
67impl fidl::Persistable for FactoryResetCountdownState {}
68
69#[derive(Clone, Debug, Default, PartialEq)]
70pub struct ProgressRendererRender2Request {
71 pub status: Option<Status>,
72 pub percent_complete: Option<f32>,
76 pub elapsed_time: Option<i64>,
80 #[doc(hidden)]
81 pub __source_breaking: fidl::marker::SourceBreaking,
82}
83
84impl fidl::Persistable for ProgressRendererRender2Request {}
85
86mod internal {
87 use super::*;
88 unsafe impl fidl::encoding::TypeMarker for Status {
89 type Owned = Self;
90
91 #[inline(always)]
92 fn inline_align(_context: fidl::encoding::Context) -> usize {
93 std::mem::align_of::<u32>()
94 }
95
96 #[inline(always)]
97 fn inline_size(_context: fidl::encoding::Context) -> usize {
98 std::mem::size_of::<u32>()
99 }
100
101 #[inline(always)]
102 fn encode_is_copy() -> bool {
103 true
104 }
105
106 #[inline(always)]
107 fn decode_is_copy() -> bool {
108 false
109 }
110 }
111
112 impl fidl::encoding::ValueTypeMarker for Status {
113 type Borrowed<'a> = Self;
114 #[inline(always)]
115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
116 *value
117 }
118 }
119
120 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Status {
121 #[inline]
122 unsafe fn encode(
123 self,
124 encoder: &mut fidl::encoding::Encoder<'_, D>,
125 offset: usize,
126 _depth: fidl::encoding::Depth,
127 ) -> fidl::Result<()> {
128 encoder.debug_check_bounds::<Self>(offset);
129 encoder.write_num(self.into_primitive(), offset);
130 Ok(())
131 }
132 }
133
134 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
135 #[inline(always)]
136 fn new_empty() -> Self {
137 Self::Active
138 }
139
140 #[inline]
141 unsafe fn decode(
142 &mut self,
143 decoder: &mut fidl::encoding::Decoder<'_, D>,
144 offset: usize,
145 _depth: fidl::encoding::Depth,
146 ) -> fidl::Result<()> {
147 decoder.debug_check_bounds::<Self>(offset);
148 let prim = decoder.read_num::<u32>(offset);
149
150 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
151 Ok(())
152 }
153 }
154
155 impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownWatchResponse {
156 type Borrowed<'a> = &'a Self;
157 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
158 value
159 }
160 }
161
162 unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownWatchResponse {
163 type Owned = Self;
164
165 #[inline(always)]
166 fn inline_align(_context: fidl::encoding::Context) -> usize {
167 8
168 }
169
170 #[inline(always)]
171 fn inline_size(_context: fidl::encoding::Context) -> usize {
172 16
173 }
174 }
175
176 unsafe impl<D: fidl::encoding::ResourceDialect>
177 fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D>
178 for &FactoryResetCountdownWatchResponse
179 {
180 #[inline]
181 unsafe fn encode(
182 self,
183 encoder: &mut fidl::encoding::Encoder<'_, D>,
184 offset: usize,
185 _depth: fidl::encoding::Depth,
186 ) -> fidl::Result<()> {
187 encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
188 fidl::encoding::Encode::<FactoryResetCountdownWatchResponse, D>::encode(
190 (<FactoryResetCountdownState as fidl::encoding::ValueTypeMarker>::borrow(
191 &self.state,
192 ),),
193 encoder,
194 offset,
195 _depth,
196 )
197 }
198 }
199 unsafe impl<
200 D: fidl::encoding::ResourceDialect,
201 T0: fidl::encoding::Encode<FactoryResetCountdownState, D>,
202 > fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D> for (T0,)
203 {
204 #[inline]
205 unsafe fn encode(
206 self,
207 encoder: &mut fidl::encoding::Encoder<'_, D>,
208 offset: usize,
209 depth: fidl::encoding::Depth,
210 ) -> fidl::Result<()> {
211 encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
212 self.0.encode(encoder, offset + 0, depth)?;
216 Ok(())
217 }
218 }
219
220 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
221 for FactoryResetCountdownWatchResponse
222 {
223 #[inline(always)]
224 fn new_empty() -> Self {
225 Self { state: fidl::new_empty!(FactoryResetCountdownState, D) }
226 }
227
228 #[inline]
229 unsafe fn decode(
230 &mut self,
231 decoder: &mut fidl::encoding::Decoder<'_, D>,
232 offset: usize,
233 _depth: fidl::encoding::Depth,
234 ) -> fidl::Result<()> {
235 decoder.debug_check_bounds::<Self>(offset);
236 fidl::decode!(
238 FactoryResetCountdownState,
239 D,
240 &mut self.state,
241 decoder,
242 offset + 0,
243 _depth
244 )?;
245 Ok(())
246 }
247 }
248
249 impl fidl::encoding::ValueTypeMarker for ProgressRendererRenderRequest {
250 type Borrowed<'a> = &'a Self;
251 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
252 value
253 }
254 }
255
256 unsafe impl fidl::encoding::TypeMarker for ProgressRendererRenderRequest {
257 type Owned = Self;
258
259 #[inline(always)]
260 fn inline_align(_context: fidl::encoding::Context) -> usize {
261 4
262 }
263
264 #[inline(always)]
265 fn inline_size(_context: fidl::encoding::Context) -> usize {
266 8
267 }
268 }
269
270 unsafe impl<D: fidl::encoding::ResourceDialect>
271 fidl::encoding::Encode<ProgressRendererRenderRequest, D>
272 for &ProgressRendererRenderRequest
273 {
274 #[inline]
275 unsafe fn encode(
276 self,
277 encoder: &mut fidl::encoding::Encoder<'_, D>,
278 offset: usize,
279 _depth: fidl::encoding::Depth,
280 ) -> fidl::Result<()> {
281 encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
282 fidl::encoding::Encode::<ProgressRendererRenderRequest, D>::encode(
284 (
285 <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
286 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.percent_complete),
287 ),
288 encoder,
289 offset,
290 _depth,
291 )
292 }
293 }
294 unsafe impl<
295 D: fidl::encoding::ResourceDialect,
296 T0: fidl::encoding::Encode<Status, D>,
297 T1: fidl::encoding::Encode<f32, D>,
298 > fidl::encoding::Encode<ProgressRendererRenderRequest, D> for (T0, T1)
299 {
300 #[inline]
301 unsafe fn encode(
302 self,
303 encoder: &mut fidl::encoding::Encoder<'_, D>,
304 offset: usize,
305 depth: fidl::encoding::Depth,
306 ) -> fidl::Result<()> {
307 encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
308 self.0.encode(encoder, offset + 0, depth)?;
312 self.1.encode(encoder, offset + 4, depth)?;
313 Ok(())
314 }
315 }
316
317 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
318 for ProgressRendererRenderRequest
319 {
320 #[inline(always)]
321 fn new_empty() -> Self {
322 Self { status: fidl::new_empty!(Status, D), percent_complete: fidl::new_empty!(f32, D) }
323 }
324
325 #[inline]
326 unsafe fn decode(
327 &mut self,
328 decoder: &mut fidl::encoding::Decoder<'_, D>,
329 offset: usize,
330 _depth: fidl::encoding::Depth,
331 ) -> fidl::Result<()> {
332 decoder.debug_check_bounds::<Self>(offset);
333 fidl::decode!(Status, D, &mut self.status, decoder, offset + 0, _depth)?;
335 fidl::decode!(f32, D, &mut self.percent_complete, decoder, offset + 4, _depth)?;
336 Ok(())
337 }
338 }
339
340 impl FactoryResetCountdownState {
341 #[inline(always)]
342 fn max_ordinal_present(&self) -> u64 {
343 if let Some(_) = self.scheduled_reset_time {
344 return 1;
345 }
346 0
347 }
348 }
349
350 impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownState {
351 type Borrowed<'a> = &'a Self;
352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
353 value
354 }
355 }
356
357 unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownState {
358 type Owned = Self;
359
360 #[inline(always)]
361 fn inline_align(_context: fidl::encoding::Context) -> usize {
362 8
363 }
364
365 #[inline(always)]
366 fn inline_size(_context: fidl::encoding::Context) -> usize {
367 16
368 }
369 }
370
371 unsafe impl<D: fidl::encoding::ResourceDialect>
372 fidl::encoding::Encode<FactoryResetCountdownState, D> for &FactoryResetCountdownState
373 {
374 unsafe fn encode(
375 self,
376 encoder: &mut fidl::encoding::Encoder<'_, D>,
377 offset: usize,
378 mut depth: fidl::encoding::Depth,
379 ) -> fidl::Result<()> {
380 encoder.debug_check_bounds::<FactoryResetCountdownState>(offset);
381 let max_ordinal: u64 = self.max_ordinal_present();
383 encoder.write_num(max_ordinal, offset);
384 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
385 if max_ordinal == 0 {
387 return Ok(());
388 }
389 depth.increment()?;
390 let envelope_size = 8;
391 let bytes_len = max_ordinal as usize * envelope_size;
392 #[allow(unused_variables)]
393 let offset = encoder.out_of_line_offset(bytes_len);
394 let mut _prev_end_offset: usize = 0;
395 if 1 > max_ordinal {
396 return Ok(());
397 }
398
399 let cur_offset: usize = (1 - 1) * envelope_size;
402
403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
405
406 fidl::encoding::encode_in_envelope_optional::<i64, D>(
411 self.scheduled_reset_time
412 .as_ref()
413 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
414 encoder,
415 offset + cur_offset,
416 depth,
417 )?;
418
419 _prev_end_offset = cur_offset + envelope_size;
420
421 Ok(())
422 }
423 }
424
425 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
426 for FactoryResetCountdownState
427 {
428 #[inline(always)]
429 fn new_empty() -> Self {
430 Self::default()
431 }
432
433 unsafe fn decode(
434 &mut self,
435 decoder: &mut fidl::encoding::Decoder<'_, D>,
436 offset: usize,
437 mut depth: fidl::encoding::Depth,
438 ) -> fidl::Result<()> {
439 decoder.debug_check_bounds::<Self>(offset);
440 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
441 None => return Err(fidl::Error::NotNullable),
442 Some(len) => len,
443 };
444 if len == 0 {
446 return Ok(());
447 };
448 depth.increment()?;
449 let envelope_size = 8;
450 let bytes_len = len * envelope_size;
451 let offset = decoder.out_of_line_offset(bytes_len)?;
452 let mut _next_ordinal_to_read = 0;
454 let mut next_offset = offset;
455 let end_offset = offset + bytes_len;
456 _next_ordinal_to_read += 1;
457 if next_offset >= end_offset {
458 return Ok(());
459 }
460
461 while _next_ordinal_to_read < 1 {
463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
464 _next_ordinal_to_read += 1;
465 next_offset += envelope_size;
466 }
467
468 let next_out_of_line = decoder.next_out_of_line();
469 let handles_before = decoder.remaining_handles();
470 if let Some((inlined, num_bytes, num_handles)) =
471 fidl::encoding::decode_envelope_header(decoder, next_offset)?
472 {
473 let member_inline_size =
474 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
475 if inlined != (member_inline_size <= 4) {
476 return Err(fidl::Error::InvalidInlineBitInEnvelope);
477 }
478 let inner_offset;
479 let mut inner_depth = depth.clone();
480 if inlined {
481 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
482 inner_offset = next_offset;
483 } else {
484 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
485 inner_depth.increment()?;
486 }
487 let val_ref =
488 self.scheduled_reset_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
489 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
490 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
491 {
492 return Err(fidl::Error::InvalidNumBytesInEnvelope);
493 }
494 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
495 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
496 }
497 }
498
499 next_offset += envelope_size;
500
501 while next_offset < end_offset {
503 _next_ordinal_to_read += 1;
504 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
505 next_offset += envelope_size;
506 }
507
508 Ok(())
509 }
510 }
511
512 impl ProgressRendererRender2Request {
513 #[inline(always)]
514 fn max_ordinal_present(&self) -> u64 {
515 if let Some(_) = self.elapsed_time {
516 return 3;
517 }
518 if let Some(_) = self.percent_complete {
519 return 2;
520 }
521 if let Some(_) = self.status {
522 return 1;
523 }
524 0
525 }
526 }
527
528 impl fidl::encoding::ValueTypeMarker for ProgressRendererRender2Request {
529 type Borrowed<'a> = &'a Self;
530 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
531 value
532 }
533 }
534
535 unsafe impl fidl::encoding::TypeMarker for ProgressRendererRender2Request {
536 type Owned = Self;
537
538 #[inline(always)]
539 fn inline_align(_context: fidl::encoding::Context) -> usize {
540 8
541 }
542
543 #[inline(always)]
544 fn inline_size(_context: fidl::encoding::Context) -> usize {
545 16
546 }
547 }
548
549 unsafe impl<D: fidl::encoding::ResourceDialect>
550 fidl::encoding::Encode<ProgressRendererRender2Request, D>
551 for &ProgressRendererRender2Request
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::<ProgressRendererRender2Request>(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::<Status, D>(
590 self.status.as_ref().map(<Status 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::<f32, D>(
613 self.percent_complete
614 .as_ref()
615 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
616 encoder,
617 offset + cur_offset,
618 depth,
619 )?;
620
621 _prev_end_offset = cur_offset + envelope_size;
622 if 3 > max_ordinal {
623 return Ok(());
624 }
625
626 let cur_offset: usize = (3 - 1) * envelope_size;
629
630 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
632
633 fidl::encoding::encode_in_envelope_optional::<i64, D>(
638 self.elapsed_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
639 encoder,
640 offset + cur_offset,
641 depth,
642 )?;
643
644 _prev_end_offset = cur_offset + envelope_size;
645
646 Ok(())
647 }
648 }
649
650 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
651 for ProgressRendererRender2Request
652 {
653 #[inline(always)]
654 fn new_empty() -> Self {
655 Self::default()
656 }
657
658 unsafe fn decode(
659 &mut self,
660 decoder: &mut fidl::encoding::Decoder<'_, D>,
661 offset: usize,
662 mut depth: fidl::encoding::Depth,
663 ) -> fidl::Result<()> {
664 decoder.debug_check_bounds::<Self>(offset);
665 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
666 None => return Err(fidl::Error::NotNullable),
667 Some(len) => len,
668 };
669 if len == 0 {
671 return Ok(());
672 };
673 depth.increment()?;
674 let envelope_size = 8;
675 let bytes_len = len * envelope_size;
676 let offset = decoder.out_of_line_offset(bytes_len)?;
677 let mut _next_ordinal_to_read = 0;
679 let mut next_offset = offset;
680 let end_offset = offset + bytes_len;
681 _next_ordinal_to_read += 1;
682 if next_offset >= end_offset {
683 return Ok(());
684 }
685
686 while _next_ordinal_to_read < 1 {
688 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
689 _next_ordinal_to_read += 1;
690 next_offset += envelope_size;
691 }
692
693 let next_out_of_line = decoder.next_out_of_line();
694 let handles_before = decoder.remaining_handles();
695 if let Some((inlined, num_bytes, num_handles)) =
696 fidl::encoding::decode_envelope_header(decoder, next_offset)?
697 {
698 let member_inline_size =
699 <Status as fidl::encoding::TypeMarker>::inline_size(decoder.context);
700 if inlined != (member_inline_size <= 4) {
701 return Err(fidl::Error::InvalidInlineBitInEnvelope);
702 }
703 let inner_offset;
704 let mut inner_depth = depth.clone();
705 if inlined {
706 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
707 inner_offset = next_offset;
708 } else {
709 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
710 inner_depth.increment()?;
711 }
712 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(Status, D));
713 fidl::decode!(Status, D, val_ref, decoder, inner_offset, inner_depth)?;
714 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
715 {
716 return Err(fidl::Error::InvalidNumBytesInEnvelope);
717 }
718 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
719 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
720 }
721 }
722
723 next_offset += envelope_size;
724 _next_ordinal_to_read += 1;
725 if next_offset >= end_offset {
726 return Ok(());
727 }
728
729 while _next_ordinal_to_read < 2 {
731 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
732 _next_ordinal_to_read += 1;
733 next_offset += envelope_size;
734 }
735
736 let next_out_of_line = decoder.next_out_of_line();
737 let handles_before = decoder.remaining_handles();
738 if let Some((inlined, num_bytes, num_handles)) =
739 fidl::encoding::decode_envelope_header(decoder, next_offset)?
740 {
741 let member_inline_size =
742 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
743 if inlined != (member_inline_size <= 4) {
744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
745 }
746 let inner_offset;
747 let mut inner_depth = depth.clone();
748 if inlined {
749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
750 inner_offset = next_offset;
751 } else {
752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
753 inner_depth.increment()?;
754 }
755 let val_ref = self.percent_complete.get_or_insert_with(|| fidl::new_empty!(f32, D));
756 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
757 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
758 {
759 return Err(fidl::Error::InvalidNumBytesInEnvelope);
760 }
761 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
762 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
763 }
764 }
765
766 next_offset += envelope_size;
767 _next_ordinal_to_read += 1;
768 if next_offset >= end_offset {
769 return Ok(());
770 }
771
772 while _next_ordinal_to_read < 3 {
774 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
775 _next_ordinal_to_read += 1;
776 next_offset += envelope_size;
777 }
778
779 let next_out_of_line = decoder.next_out_of_line();
780 let handles_before = decoder.remaining_handles();
781 if let Some((inlined, num_bytes, num_handles)) =
782 fidl::encoding::decode_envelope_header(decoder, next_offset)?
783 {
784 let member_inline_size =
785 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
786 if inlined != (member_inline_size <= 4) {
787 return Err(fidl::Error::InvalidInlineBitInEnvelope);
788 }
789 let inner_offset;
790 let mut inner_depth = depth.clone();
791 if inlined {
792 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
793 inner_offset = next_offset;
794 } else {
795 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
796 inner_depth.increment()?;
797 }
798 let val_ref = self.elapsed_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
799 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
800 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
801 {
802 return Err(fidl::Error::InvalidNumBytesInEnvelope);
803 }
804 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
805 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
806 }
807 }
808
809 next_offset += envelope_size;
810
811 while next_offset < end_offset {
813 _next_ordinal_to_read += 1;
814 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
815 next_offset += envelope_size;
816 }
817
818 Ok(())
819 }
820 }
821}