fidl_fuchsia_recovery_ui__common/
fidl_fuchsia_recovery_ui__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![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/// Information provided through the FactoryResetCountdown protocol on the
56/// current factory reset state.
57#[derive(Clone, Debug, Default, PartialEq)]
58pub struct FactoryResetCountdownState {
59    /// The time of when factory reset is scheduled to be triggered when a
60    /// countdown for factory reset is in progress with respect to the monotonic
61    /// clock. This field is left unpopulated if no reset is scheduled.
62    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    /// Optional, only used with status ACTIVE
73    /// No value or an invalid value sets the progress bar to 0%
74    /// Values: [0.0 - 100.0]
75    pub percent_complete: Option<f32>,
76    /// Time to take to move slowly to percent_complete
77    /// Optional, only used with status ACTIVE
78    /// No value indicates an instant jump to percent_complete
79    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            // Delegate to tuple encoding.
198            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            // Zero out padding regions. There's no need to apply masks
222            // because the unmasked parts will be overwritten by fields.
223            // Write the fields.
224            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            // Verify that padding bytes are zero.
246            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            // Delegate to tuple encoding.
292            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            // Zero out padding regions. There's no need to apply masks
318            // because the unmasked parts will be overwritten by fields.
319            // Write the fields.
320            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            // Verify that padding bytes are zero.
343            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            // Vector header
391            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            // Calling encoder.out_of_line_offset(0) is not allowed.
395            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
409            // are envelope_size bytes.
410            let cur_offset: usize = (1 - 1) * envelope_size;
411
412            // Zero reserved fields.
413            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
414
415            // Safety:
416            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
417            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
418            //   envelope_size bytes, there is always sufficient room.
419            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            // Calling decoder.out_of_line_offset(0) is not allowed.
454            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            // Decode the envelope for each type.
462            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            // Decode unknown envelopes for gaps in ordinals.
471            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            // Decode the remaining unknown envelopes.
511            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            // Vector header
570            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            // Calling encoder.out_of_line_offset(0) is not allowed.
574            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
588            // are envelope_size bytes.
589            let cur_offset: usize = (1 - 1) * envelope_size;
590
591            // Zero reserved fields.
592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
593
594            // Safety:
595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
597            //   envelope_size bytes, there is always sufficient room.
598            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
611            // are envelope_size bytes.
612            let cur_offset: usize = (2 - 1) * envelope_size;
613
614            // Zero reserved fields.
615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
616
617            // Safety:
618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
620            //   envelope_size bytes, there is always sufficient room.
621            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            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
636            // are envelope_size bytes.
637            let cur_offset: usize = (3 - 1) * envelope_size;
638
639            // Zero reserved fields.
640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
641
642            // Safety:
643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
645            //   envelope_size bytes, there is always sufficient room.
646            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            // Calling decoder.out_of_line_offset(0) is not allowed.
679            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            // Decode the envelope for each type.
687            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            // Decode unknown envelopes for gaps in ordinals.
696            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            // Decode unknown envelopes for gaps in ordinals.
739            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            // Decode unknown envelopes for gaps in ordinals.
782            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            // Decode the remaining unknown envelopes.
821            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}