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
86pub mod factory_reset_countdown_ordinals {
87 pub const WATCH: u64 = 0x1d486a7889bc943a;
88}
89
90pub mod progress_renderer_ordinals {
91 pub const RENDER: u64 = 0x68f03b362c8c1a54;
92 pub const RENDER2: u64 = 0x218acc9beba72126;
93}
94
95mod internal {
96 use super::*;
97 unsafe impl fidl::encoding::TypeMarker for Status {
98 type Owned = Self;
99
100 #[inline(always)]
101 fn inline_align(_context: fidl::encoding::Context) -> usize {
102 std::mem::align_of::<u32>()
103 }
104
105 #[inline(always)]
106 fn inline_size(_context: fidl::encoding::Context) -> usize {
107 std::mem::size_of::<u32>()
108 }
109
110 #[inline(always)]
111 fn encode_is_copy() -> bool {
112 true
113 }
114
115 #[inline(always)]
116 fn decode_is_copy() -> bool {
117 false
118 }
119 }
120
121 impl fidl::encoding::ValueTypeMarker for Status {
122 type Borrowed<'a> = Self;
123 #[inline(always)]
124 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
125 *value
126 }
127 }
128
129 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Status {
130 #[inline]
131 unsafe fn encode(
132 self,
133 encoder: &mut fidl::encoding::Encoder<'_, D>,
134 offset: usize,
135 _depth: fidl::encoding::Depth,
136 ) -> fidl::Result<()> {
137 encoder.debug_check_bounds::<Self>(offset);
138 encoder.write_num(self.into_primitive(), offset);
139 Ok(())
140 }
141 }
142
143 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
144 #[inline(always)]
145 fn new_empty() -> Self {
146 Self::Active
147 }
148
149 #[inline]
150 unsafe fn decode(
151 &mut self,
152 decoder: &mut fidl::encoding::Decoder<'_, D>,
153 offset: usize,
154 _depth: fidl::encoding::Depth,
155 ) -> fidl::Result<()> {
156 decoder.debug_check_bounds::<Self>(offset);
157 let prim = decoder.read_num::<u32>(offset);
158
159 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
160 Ok(())
161 }
162 }
163
164 impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownWatchResponse {
165 type Borrowed<'a> = &'a Self;
166 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
167 value
168 }
169 }
170
171 unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownWatchResponse {
172 type Owned = Self;
173
174 #[inline(always)]
175 fn inline_align(_context: fidl::encoding::Context) -> usize {
176 8
177 }
178
179 #[inline(always)]
180 fn inline_size(_context: fidl::encoding::Context) -> usize {
181 16
182 }
183 }
184
185 unsafe impl<D: fidl::encoding::ResourceDialect>
186 fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D>
187 for &FactoryResetCountdownWatchResponse
188 {
189 #[inline]
190 unsafe fn encode(
191 self,
192 encoder: &mut fidl::encoding::Encoder<'_, D>,
193 offset: usize,
194 _depth: fidl::encoding::Depth,
195 ) -> fidl::Result<()> {
196 encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
197 fidl::encoding::Encode::<FactoryResetCountdownWatchResponse, D>::encode(
199 (<FactoryResetCountdownState as fidl::encoding::ValueTypeMarker>::borrow(
200 &self.state,
201 ),),
202 encoder,
203 offset,
204 _depth,
205 )
206 }
207 }
208 unsafe impl<
209 D: fidl::encoding::ResourceDialect,
210 T0: fidl::encoding::Encode<FactoryResetCountdownState, D>,
211 > fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D> for (T0,)
212 {
213 #[inline]
214 unsafe fn encode(
215 self,
216 encoder: &mut fidl::encoding::Encoder<'_, D>,
217 offset: usize,
218 depth: fidl::encoding::Depth,
219 ) -> fidl::Result<()> {
220 encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
221 self.0.encode(encoder, offset + 0, depth)?;
225 Ok(())
226 }
227 }
228
229 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
230 for FactoryResetCountdownWatchResponse
231 {
232 #[inline(always)]
233 fn new_empty() -> Self {
234 Self { state: fidl::new_empty!(FactoryResetCountdownState, D) }
235 }
236
237 #[inline]
238 unsafe fn decode(
239 &mut self,
240 decoder: &mut fidl::encoding::Decoder<'_, D>,
241 offset: usize,
242 _depth: fidl::encoding::Depth,
243 ) -> fidl::Result<()> {
244 decoder.debug_check_bounds::<Self>(offset);
245 fidl::decode!(
247 FactoryResetCountdownState,
248 D,
249 &mut self.state,
250 decoder,
251 offset + 0,
252 _depth
253 )?;
254 Ok(())
255 }
256 }
257
258 impl fidl::encoding::ValueTypeMarker for ProgressRendererRenderRequest {
259 type Borrowed<'a> = &'a Self;
260 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
261 value
262 }
263 }
264
265 unsafe impl fidl::encoding::TypeMarker for ProgressRendererRenderRequest {
266 type Owned = Self;
267
268 #[inline(always)]
269 fn inline_align(_context: fidl::encoding::Context) -> usize {
270 4
271 }
272
273 #[inline(always)]
274 fn inline_size(_context: fidl::encoding::Context) -> usize {
275 8
276 }
277 }
278
279 unsafe impl<D: fidl::encoding::ResourceDialect>
280 fidl::encoding::Encode<ProgressRendererRenderRequest, D>
281 for &ProgressRendererRenderRequest
282 {
283 #[inline]
284 unsafe fn encode(
285 self,
286 encoder: &mut fidl::encoding::Encoder<'_, D>,
287 offset: usize,
288 _depth: fidl::encoding::Depth,
289 ) -> fidl::Result<()> {
290 encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
291 fidl::encoding::Encode::<ProgressRendererRenderRequest, D>::encode(
293 (
294 <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
295 <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.percent_complete),
296 ),
297 encoder,
298 offset,
299 _depth,
300 )
301 }
302 }
303 unsafe impl<
304 D: fidl::encoding::ResourceDialect,
305 T0: fidl::encoding::Encode<Status, D>,
306 T1: fidl::encoding::Encode<f32, D>,
307 > fidl::encoding::Encode<ProgressRendererRenderRequest, D> for (T0, T1)
308 {
309 #[inline]
310 unsafe fn encode(
311 self,
312 encoder: &mut fidl::encoding::Encoder<'_, D>,
313 offset: usize,
314 depth: fidl::encoding::Depth,
315 ) -> fidl::Result<()> {
316 encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
317 self.0.encode(encoder, offset + 0, depth)?;
321 self.1.encode(encoder, offset + 4, depth)?;
322 Ok(())
323 }
324 }
325
326 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
327 for ProgressRendererRenderRequest
328 {
329 #[inline(always)]
330 fn new_empty() -> Self {
331 Self { status: fidl::new_empty!(Status, D), percent_complete: fidl::new_empty!(f32, D) }
332 }
333
334 #[inline]
335 unsafe fn decode(
336 &mut self,
337 decoder: &mut fidl::encoding::Decoder<'_, D>,
338 offset: usize,
339 _depth: fidl::encoding::Depth,
340 ) -> fidl::Result<()> {
341 decoder.debug_check_bounds::<Self>(offset);
342 fidl::decode!(Status, D, &mut self.status, decoder, offset + 0, _depth)?;
344 fidl::decode!(f32, D, &mut self.percent_complete, decoder, offset + 4, _depth)?;
345 Ok(())
346 }
347 }
348
349 impl FactoryResetCountdownState {
350 #[inline(always)]
351 fn max_ordinal_present(&self) -> u64 {
352 if let Some(_) = self.scheduled_reset_time {
353 return 1;
354 }
355 0
356 }
357 }
358
359 impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownState {
360 type Borrowed<'a> = &'a Self;
361 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
362 value
363 }
364 }
365
366 unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownState {
367 type Owned = Self;
368
369 #[inline(always)]
370 fn inline_align(_context: fidl::encoding::Context) -> usize {
371 8
372 }
373
374 #[inline(always)]
375 fn inline_size(_context: fidl::encoding::Context) -> usize {
376 16
377 }
378 }
379
380 unsafe impl<D: fidl::encoding::ResourceDialect>
381 fidl::encoding::Encode<FactoryResetCountdownState, D> for &FactoryResetCountdownState
382 {
383 unsafe fn encode(
384 self,
385 encoder: &mut fidl::encoding::Encoder<'_, D>,
386 offset: usize,
387 mut depth: fidl::encoding::Depth,
388 ) -> fidl::Result<()> {
389 encoder.debug_check_bounds::<FactoryResetCountdownState>(offset);
390 let max_ordinal: u64 = self.max_ordinal_present();
392 encoder.write_num(max_ordinal, offset);
393 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
394 if max_ordinal == 0 {
396 return Ok(());
397 }
398 depth.increment()?;
399 let envelope_size = 8;
400 let bytes_len = max_ordinal as usize * envelope_size;
401 #[allow(unused_variables)]
402 let offset = encoder.out_of_line_offset(bytes_len);
403 let mut _prev_end_offset: usize = 0;
404 if 1 > max_ordinal {
405 return Ok(());
406 }
407
408 let cur_offset: usize = (1 - 1) * envelope_size;
411
412 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
414
415 fidl::encoding::encode_in_envelope_optional::<i64, D>(
420 self.scheduled_reset_time
421 .as_ref()
422 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
423 encoder,
424 offset + cur_offset,
425 depth,
426 )?;
427
428 _prev_end_offset = cur_offset + envelope_size;
429
430 Ok(())
431 }
432 }
433
434 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
435 for FactoryResetCountdownState
436 {
437 #[inline(always)]
438 fn new_empty() -> Self {
439 Self::default()
440 }
441
442 unsafe fn decode(
443 &mut self,
444 decoder: &mut fidl::encoding::Decoder<'_, D>,
445 offset: usize,
446 mut depth: fidl::encoding::Depth,
447 ) -> fidl::Result<()> {
448 decoder.debug_check_bounds::<Self>(offset);
449 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
450 None => return Err(fidl::Error::NotNullable),
451 Some(len) => len,
452 };
453 if len == 0 {
455 return Ok(());
456 };
457 depth.increment()?;
458 let envelope_size = 8;
459 let bytes_len = len * envelope_size;
460 let offset = decoder.out_of_line_offset(bytes_len)?;
461 let mut _next_ordinal_to_read = 0;
463 let mut next_offset = offset;
464 let end_offset = offset + bytes_len;
465 _next_ordinal_to_read += 1;
466 if next_offset >= end_offset {
467 return Ok(());
468 }
469
470 while _next_ordinal_to_read < 1 {
472 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
473 _next_ordinal_to_read += 1;
474 next_offset += envelope_size;
475 }
476
477 let next_out_of_line = decoder.next_out_of_line();
478 let handles_before = decoder.remaining_handles();
479 if let Some((inlined, num_bytes, num_handles)) =
480 fidl::encoding::decode_envelope_header(decoder, next_offset)?
481 {
482 let member_inline_size =
483 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
484 if inlined != (member_inline_size <= 4) {
485 return Err(fidl::Error::InvalidInlineBitInEnvelope);
486 }
487 let inner_offset;
488 let mut inner_depth = depth.clone();
489 if inlined {
490 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
491 inner_offset = next_offset;
492 } else {
493 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
494 inner_depth.increment()?;
495 }
496 let val_ref =
497 self.scheduled_reset_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
498 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
499 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
500 {
501 return Err(fidl::Error::InvalidNumBytesInEnvelope);
502 }
503 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
504 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
505 }
506 }
507
508 next_offset += envelope_size;
509
510 while next_offset < end_offset {
512 _next_ordinal_to_read += 1;
513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
514 next_offset += envelope_size;
515 }
516
517 Ok(())
518 }
519 }
520
521 impl ProgressRendererRender2Request {
522 #[inline(always)]
523 fn max_ordinal_present(&self) -> u64 {
524 if let Some(_) = self.elapsed_time {
525 return 3;
526 }
527 if let Some(_) = self.percent_complete {
528 return 2;
529 }
530 if let Some(_) = self.status {
531 return 1;
532 }
533 0
534 }
535 }
536
537 impl fidl::encoding::ValueTypeMarker for ProgressRendererRender2Request {
538 type Borrowed<'a> = &'a Self;
539 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
540 value
541 }
542 }
543
544 unsafe impl fidl::encoding::TypeMarker for ProgressRendererRender2Request {
545 type Owned = Self;
546
547 #[inline(always)]
548 fn inline_align(_context: fidl::encoding::Context) -> usize {
549 8
550 }
551
552 #[inline(always)]
553 fn inline_size(_context: fidl::encoding::Context) -> usize {
554 16
555 }
556 }
557
558 unsafe impl<D: fidl::encoding::ResourceDialect>
559 fidl::encoding::Encode<ProgressRendererRender2Request, D>
560 for &ProgressRendererRender2Request
561 {
562 unsafe fn encode(
563 self,
564 encoder: &mut fidl::encoding::Encoder<'_, D>,
565 offset: usize,
566 mut depth: fidl::encoding::Depth,
567 ) -> fidl::Result<()> {
568 encoder.debug_check_bounds::<ProgressRendererRender2Request>(offset);
569 let max_ordinal: u64 = self.max_ordinal_present();
571 encoder.write_num(max_ordinal, offset);
572 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
573 if max_ordinal == 0 {
575 return Ok(());
576 }
577 depth.increment()?;
578 let envelope_size = 8;
579 let bytes_len = max_ordinal as usize * envelope_size;
580 #[allow(unused_variables)]
581 let offset = encoder.out_of_line_offset(bytes_len);
582 let mut _prev_end_offset: usize = 0;
583 if 1 > max_ordinal {
584 return Ok(());
585 }
586
587 let cur_offset: usize = (1 - 1) * envelope_size;
590
591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
593
594 fidl::encoding::encode_in_envelope_optional::<Status, D>(
599 self.status.as_ref().map(<Status as fidl::encoding::ValueTypeMarker>::borrow),
600 encoder,
601 offset + cur_offset,
602 depth,
603 )?;
604
605 _prev_end_offset = cur_offset + envelope_size;
606 if 2 > max_ordinal {
607 return Ok(());
608 }
609
610 let cur_offset: usize = (2 - 1) * envelope_size;
613
614 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
616
617 fidl::encoding::encode_in_envelope_optional::<f32, D>(
622 self.percent_complete
623 .as_ref()
624 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
625 encoder,
626 offset + cur_offset,
627 depth,
628 )?;
629
630 _prev_end_offset = cur_offset + envelope_size;
631 if 3 > max_ordinal {
632 return Ok(());
633 }
634
635 let cur_offset: usize = (3 - 1) * envelope_size;
638
639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
641
642 fidl::encoding::encode_in_envelope_optional::<i64, D>(
647 self.elapsed_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
648 encoder,
649 offset + cur_offset,
650 depth,
651 )?;
652
653 _prev_end_offset = cur_offset + envelope_size;
654
655 Ok(())
656 }
657 }
658
659 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
660 for ProgressRendererRender2Request
661 {
662 #[inline(always)]
663 fn new_empty() -> Self {
664 Self::default()
665 }
666
667 unsafe fn decode(
668 &mut self,
669 decoder: &mut fidl::encoding::Decoder<'_, D>,
670 offset: usize,
671 mut depth: fidl::encoding::Depth,
672 ) -> fidl::Result<()> {
673 decoder.debug_check_bounds::<Self>(offset);
674 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
675 None => return Err(fidl::Error::NotNullable),
676 Some(len) => len,
677 };
678 if len == 0 {
680 return Ok(());
681 };
682 depth.increment()?;
683 let envelope_size = 8;
684 let bytes_len = len * envelope_size;
685 let offset = decoder.out_of_line_offset(bytes_len)?;
686 let mut _next_ordinal_to_read = 0;
688 let mut next_offset = offset;
689 let end_offset = offset + bytes_len;
690 _next_ordinal_to_read += 1;
691 if next_offset >= end_offset {
692 return Ok(());
693 }
694
695 while _next_ordinal_to_read < 1 {
697 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
698 _next_ordinal_to_read += 1;
699 next_offset += envelope_size;
700 }
701
702 let next_out_of_line = decoder.next_out_of_line();
703 let handles_before = decoder.remaining_handles();
704 if let Some((inlined, num_bytes, num_handles)) =
705 fidl::encoding::decode_envelope_header(decoder, next_offset)?
706 {
707 let member_inline_size =
708 <Status as fidl::encoding::TypeMarker>::inline_size(decoder.context);
709 if inlined != (member_inline_size <= 4) {
710 return Err(fidl::Error::InvalidInlineBitInEnvelope);
711 }
712 let inner_offset;
713 let mut inner_depth = depth.clone();
714 if inlined {
715 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
716 inner_offset = next_offset;
717 } else {
718 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
719 inner_depth.increment()?;
720 }
721 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(Status, D));
722 fidl::decode!(Status, D, val_ref, decoder, inner_offset, inner_depth)?;
723 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
724 {
725 return Err(fidl::Error::InvalidNumBytesInEnvelope);
726 }
727 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
728 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
729 }
730 }
731
732 next_offset += envelope_size;
733 _next_ordinal_to_read += 1;
734 if next_offset >= end_offset {
735 return Ok(());
736 }
737
738 while _next_ordinal_to_read < 2 {
740 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
741 _next_ordinal_to_read += 1;
742 next_offset += envelope_size;
743 }
744
745 let next_out_of_line = decoder.next_out_of_line();
746 let handles_before = decoder.remaining_handles();
747 if let Some((inlined, num_bytes, num_handles)) =
748 fidl::encoding::decode_envelope_header(decoder, next_offset)?
749 {
750 let member_inline_size =
751 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
752 if inlined != (member_inline_size <= 4) {
753 return Err(fidl::Error::InvalidInlineBitInEnvelope);
754 }
755 let inner_offset;
756 let mut inner_depth = depth.clone();
757 if inlined {
758 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
759 inner_offset = next_offset;
760 } else {
761 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
762 inner_depth.increment()?;
763 }
764 let val_ref = self.percent_complete.get_or_insert_with(|| fidl::new_empty!(f32, D));
765 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
766 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
767 {
768 return Err(fidl::Error::InvalidNumBytesInEnvelope);
769 }
770 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
771 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
772 }
773 }
774
775 next_offset += envelope_size;
776 _next_ordinal_to_read += 1;
777 if next_offset >= end_offset {
778 return Ok(());
779 }
780
781 while _next_ordinal_to_read < 3 {
783 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
784 _next_ordinal_to_read += 1;
785 next_offset += envelope_size;
786 }
787
788 let next_out_of_line = decoder.next_out_of_line();
789 let handles_before = decoder.remaining_handles();
790 if let Some((inlined, num_bytes, num_handles)) =
791 fidl::encoding::decode_envelope_header(decoder, next_offset)?
792 {
793 let member_inline_size =
794 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
795 if inlined != (member_inline_size <= 4) {
796 return Err(fidl::Error::InvalidInlineBitInEnvelope);
797 }
798 let inner_offset;
799 let mut inner_depth = depth.clone();
800 if inlined {
801 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
802 inner_offset = next_offset;
803 } else {
804 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
805 inner_depth.increment()?;
806 }
807 let val_ref = self.elapsed_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
808 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
809 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
810 {
811 return Err(fidl::Error::InvalidNumBytesInEnvelope);
812 }
813 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
814 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
815 }
816 }
817
818 next_offset += envelope_size;
819
820 while next_offset < end_offset {
822 _next_ordinal_to_read += 1;
823 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
824 next_offset += envelope_size;
825 }
826
827 Ok(())
828 }
829 }
830}