fidl_test_suspendcontrol__common/
fidl_test_suspendcontrol__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(Clone, Debug, Default, PartialEq)]
12pub struct DeviceSetSuspendStatesRequest {
13    pub suspend_states: Option<Vec<fidl_fuchsia_hardware_power_suspend__common::SuspendState>>,
14    #[doc(hidden)]
15    pub __source_breaking: fidl::marker::SourceBreaking,
16}
17
18impl fidl::Persistable for DeviceSetSuspendStatesRequest {}
19
20#[derive(Clone, Debug, Default, PartialEq)]
21pub struct DeviceAwaitSuspendResponse {
22    pub state_index: Option<u64>,
23    #[doc(hidden)]
24    pub __source_breaking: fidl::marker::SourceBreaking,
25}
26
27impl fidl::Persistable for DeviceAwaitSuspendResponse {}
28
29#[derive(Clone, Debug, Default, PartialEq)]
30pub struct SuspendResult {
31    pub reason: Option<fidl_fuchsia_hardware_power_suspend__common::WakeReason>,
32    pub suspend_duration: Option<i64>,
33    pub suspend_overhead: Option<i64>,
34    #[doc(hidden)]
35    pub __source_breaking: fidl::marker::SourceBreaking,
36}
37
38impl fidl::Persistable for SuspendResult {}
39
40#[derive(Clone, Debug)]
41pub enum DeviceResumeRequest {
42    Result(SuspendResult),
43    Error(i32),
44    #[doc(hidden)]
45    __SourceBreaking {
46        unknown_ordinal: u64,
47    },
48}
49
50/// Pattern that matches an unknown `DeviceResumeRequest` member.
51#[macro_export]
52macro_rules! DeviceResumeRequestUnknown {
53    () => {
54        _
55    };
56}
57
58// Custom PartialEq so that unknown variants are not equal to themselves.
59impl PartialEq for DeviceResumeRequest {
60    fn eq(&self, other: &Self) -> bool {
61        match (self, other) {
62            (Self::Result(x), Self::Result(y)) => *x == *y,
63            (Self::Error(x), Self::Error(y)) => *x == *y,
64            _ => false,
65        }
66    }
67}
68
69impl DeviceResumeRequest {
70    #[inline]
71    pub fn ordinal(&self) -> u64 {
72        match *self {
73            Self::Result(_) => 1,
74            Self::Error(_) => 2,
75            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
76        }
77    }
78
79    #[inline]
80    pub fn unknown_variant_for_testing() -> Self {
81        Self::__SourceBreaking { unknown_ordinal: 0 }
82    }
83
84    #[inline]
85    pub fn is_unknown(&self) -> bool {
86        match self {
87            Self::__SourceBreaking { .. } => true,
88            _ => false,
89        }
90    }
91}
92
93impl fidl::Persistable for DeviceResumeRequest {}
94
95mod internal {
96    use super::*;
97
98    impl DeviceSetSuspendStatesRequest {
99        #[inline(always)]
100        fn max_ordinal_present(&self) -> u64 {
101            if let Some(_) = self.suspend_states {
102                return 1;
103            }
104            0
105        }
106    }
107
108    impl fidl::encoding::ValueTypeMarker for DeviceSetSuspendStatesRequest {
109        type Borrowed<'a> = &'a Self;
110        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
111            value
112        }
113    }
114
115    unsafe impl fidl::encoding::TypeMarker for DeviceSetSuspendStatesRequest {
116        type Owned = Self;
117
118        #[inline(always)]
119        fn inline_align(_context: fidl::encoding::Context) -> usize {
120            8
121        }
122
123        #[inline(always)]
124        fn inline_size(_context: fidl::encoding::Context) -> usize {
125            16
126        }
127    }
128
129    unsafe impl<D: fidl::encoding::ResourceDialect>
130        fidl::encoding::Encode<DeviceSetSuspendStatesRequest, D>
131        for &DeviceSetSuspendStatesRequest
132    {
133        unsafe fn encode(
134            self,
135            encoder: &mut fidl::encoding::Encoder<'_, D>,
136            offset: usize,
137            mut depth: fidl::encoding::Depth,
138        ) -> fidl::Result<()> {
139            encoder.debug_check_bounds::<DeviceSetSuspendStatesRequest>(offset);
140            // Vector header
141            let max_ordinal: u64 = self.max_ordinal_present();
142            encoder.write_num(max_ordinal, offset);
143            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
144            // Calling encoder.out_of_line_offset(0) is not allowed.
145            if max_ordinal == 0 {
146                return Ok(());
147            }
148            depth.increment()?;
149            let envelope_size = 8;
150            let bytes_len = max_ordinal as usize * envelope_size;
151            #[allow(unused_variables)]
152            let offset = encoder.out_of_line_offset(bytes_len);
153            let mut _prev_end_offset: usize = 0;
154            if 1 > max_ordinal {
155                return Ok(());
156            }
157
158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
159            // are envelope_size bytes.
160            let cur_offset: usize = (1 - 1) * envelope_size;
161
162            // Zero reserved fields.
163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
164
165            // Safety:
166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
168            //   envelope_size bytes, there is always sufficient room.
169            fidl::encoding::encode_in_envelope_optional::<
170                fidl::encoding::Vector<
171                    fidl_fuchsia_hardware_power_suspend__common::SuspendState,
172                    256,
173                >,
174                D,
175            >(
176                self.suspend_states.as_ref().map(
177                    <fidl::encoding::Vector<
178                        fidl_fuchsia_hardware_power_suspend__common::SuspendState,
179                        256,
180                    > as fidl::encoding::ValueTypeMarker>::borrow,
181                ),
182                encoder,
183                offset + cur_offset,
184                depth,
185            )?;
186
187            _prev_end_offset = cur_offset + envelope_size;
188
189            Ok(())
190        }
191    }
192
193    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
194        for DeviceSetSuspendStatesRequest
195    {
196        #[inline(always)]
197        fn new_empty() -> Self {
198            Self::default()
199        }
200
201        unsafe fn decode(
202            &mut self,
203            decoder: &mut fidl::encoding::Decoder<'_, D>,
204            offset: usize,
205            mut depth: fidl::encoding::Depth,
206        ) -> fidl::Result<()> {
207            decoder.debug_check_bounds::<Self>(offset);
208            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
209                None => return Err(fidl::Error::NotNullable),
210                Some(len) => len,
211            };
212            // Calling decoder.out_of_line_offset(0) is not allowed.
213            if len == 0 {
214                return Ok(());
215            };
216            depth.increment()?;
217            let envelope_size = 8;
218            let bytes_len = len * envelope_size;
219            let offset = decoder.out_of_line_offset(bytes_len)?;
220            // Decode the envelope for each type.
221            let mut _next_ordinal_to_read = 0;
222            let mut next_offset = offset;
223            let end_offset = offset + bytes_len;
224            _next_ordinal_to_read += 1;
225            if next_offset >= end_offset {
226                return Ok(());
227            }
228
229            // Decode unknown envelopes for gaps in ordinals.
230            while _next_ordinal_to_read < 1 {
231                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
232                _next_ordinal_to_read += 1;
233                next_offset += envelope_size;
234            }
235
236            let next_out_of_line = decoder.next_out_of_line();
237            let handles_before = decoder.remaining_handles();
238            if let Some((inlined, num_bytes, num_handles)) =
239                fidl::encoding::decode_envelope_header(decoder, next_offset)?
240            {
241                let member_inline_size = <fidl::encoding::Vector<
242                    fidl_fuchsia_hardware_power_suspend__common::SuspendState,
243                    256,
244                > as fidl::encoding::TypeMarker>::inline_size(
245                    decoder.context
246                );
247                if inlined != (member_inline_size <= 4) {
248                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
249                }
250                let inner_offset;
251                let mut inner_depth = depth.clone();
252                if inlined {
253                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
254                    inner_offset = next_offset;
255                } else {
256                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
257                    inner_depth.increment()?;
258                }
259                let val_ref =
260                self.suspend_states.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D));
261                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_power_suspend__common::SuspendState, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
262                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
263                {
264                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
265                }
266                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
267                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
268                }
269            }
270
271            next_offset += envelope_size;
272
273            // Decode the remaining unknown envelopes.
274            while next_offset < end_offset {
275                _next_ordinal_to_read += 1;
276                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
277                next_offset += envelope_size;
278            }
279
280            Ok(())
281        }
282    }
283
284    impl DeviceAwaitSuspendResponse {
285        #[inline(always)]
286        fn max_ordinal_present(&self) -> u64 {
287            if let Some(_) = self.state_index {
288                return 1;
289            }
290            0
291        }
292    }
293
294    impl fidl::encoding::ValueTypeMarker for DeviceAwaitSuspendResponse {
295        type Borrowed<'a> = &'a Self;
296        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297            value
298        }
299    }
300
301    unsafe impl fidl::encoding::TypeMarker for DeviceAwaitSuspendResponse {
302        type Owned = Self;
303
304        #[inline(always)]
305        fn inline_align(_context: fidl::encoding::Context) -> usize {
306            8
307        }
308
309        #[inline(always)]
310        fn inline_size(_context: fidl::encoding::Context) -> usize {
311            16
312        }
313    }
314
315    unsafe impl<D: fidl::encoding::ResourceDialect>
316        fidl::encoding::Encode<DeviceAwaitSuspendResponse, D> for &DeviceAwaitSuspendResponse
317    {
318        unsafe fn encode(
319            self,
320            encoder: &mut fidl::encoding::Encoder<'_, D>,
321            offset: usize,
322            mut depth: fidl::encoding::Depth,
323        ) -> fidl::Result<()> {
324            encoder.debug_check_bounds::<DeviceAwaitSuspendResponse>(offset);
325            // Vector header
326            let max_ordinal: u64 = self.max_ordinal_present();
327            encoder.write_num(max_ordinal, offset);
328            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
329            // Calling encoder.out_of_line_offset(0) is not allowed.
330            if max_ordinal == 0 {
331                return Ok(());
332            }
333            depth.increment()?;
334            let envelope_size = 8;
335            let bytes_len = max_ordinal as usize * envelope_size;
336            #[allow(unused_variables)]
337            let offset = encoder.out_of_line_offset(bytes_len);
338            let mut _prev_end_offset: usize = 0;
339            if 1 > max_ordinal {
340                return Ok(());
341            }
342
343            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
344            // are envelope_size bytes.
345            let cur_offset: usize = (1 - 1) * envelope_size;
346
347            // Zero reserved fields.
348            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
349
350            // Safety:
351            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
352            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
353            //   envelope_size bytes, there is always sufficient room.
354            fidl::encoding::encode_in_envelope_optional::<u64, D>(
355                self.state_index.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
356                encoder,
357                offset + cur_offset,
358                depth,
359            )?;
360
361            _prev_end_offset = cur_offset + envelope_size;
362
363            Ok(())
364        }
365    }
366
367    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
368        for DeviceAwaitSuspendResponse
369    {
370        #[inline(always)]
371        fn new_empty() -> Self {
372            Self::default()
373        }
374
375        unsafe fn decode(
376            &mut self,
377            decoder: &mut fidl::encoding::Decoder<'_, D>,
378            offset: usize,
379            mut depth: fidl::encoding::Depth,
380        ) -> fidl::Result<()> {
381            decoder.debug_check_bounds::<Self>(offset);
382            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
383                None => return Err(fidl::Error::NotNullable),
384                Some(len) => len,
385            };
386            // Calling decoder.out_of_line_offset(0) is not allowed.
387            if len == 0 {
388                return Ok(());
389            };
390            depth.increment()?;
391            let envelope_size = 8;
392            let bytes_len = len * envelope_size;
393            let offset = decoder.out_of_line_offset(bytes_len)?;
394            // Decode the envelope for each type.
395            let mut _next_ordinal_to_read = 0;
396            let mut next_offset = offset;
397            let end_offset = offset + bytes_len;
398            _next_ordinal_to_read += 1;
399            if next_offset >= end_offset {
400                return Ok(());
401            }
402
403            // Decode unknown envelopes for gaps in ordinals.
404            while _next_ordinal_to_read < 1 {
405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
406                _next_ordinal_to_read += 1;
407                next_offset += envelope_size;
408            }
409
410            let next_out_of_line = decoder.next_out_of_line();
411            let handles_before = decoder.remaining_handles();
412            if let Some((inlined, num_bytes, num_handles)) =
413                fidl::encoding::decode_envelope_header(decoder, next_offset)?
414            {
415                let member_inline_size =
416                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
417                if inlined != (member_inline_size <= 4) {
418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
419                }
420                let inner_offset;
421                let mut inner_depth = depth.clone();
422                if inlined {
423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
424                    inner_offset = next_offset;
425                } else {
426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
427                    inner_depth.increment()?;
428                }
429                let val_ref = self.state_index.get_or_insert_with(|| fidl::new_empty!(u64, D));
430                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
431                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
432                {
433                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
434                }
435                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
436                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
437                }
438            }
439
440            next_offset += envelope_size;
441
442            // Decode the remaining unknown envelopes.
443            while next_offset < end_offset {
444                _next_ordinal_to_read += 1;
445                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
446                next_offset += envelope_size;
447            }
448
449            Ok(())
450        }
451    }
452
453    impl SuspendResult {
454        #[inline(always)]
455        fn max_ordinal_present(&self) -> u64 {
456            if let Some(_) = self.suspend_overhead {
457                return 3;
458            }
459            if let Some(_) = self.suspend_duration {
460                return 2;
461            }
462            if let Some(_) = self.reason {
463                return 1;
464            }
465            0
466        }
467    }
468
469    impl fidl::encoding::ValueTypeMarker for SuspendResult {
470        type Borrowed<'a> = &'a Self;
471        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
472            value
473        }
474    }
475
476    unsafe impl fidl::encoding::TypeMarker for SuspendResult {
477        type Owned = Self;
478
479        #[inline(always)]
480        fn inline_align(_context: fidl::encoding::Context) -> usize {
481            8
482        }
483
484        #[inline(always)]
485        fn inline_size(_context: fidl::encoding::Context) -> usize {
486            16
487        }
488    }
489
490    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SuspendResult, D>
491        for &SuspendResult
492    {
493        unsafe fn encode(
494            self,
495            encoder: &mut fidl::encoding::Encoder<'_, D>,
496            offset: usize,
497            mut depth: fidl::encoding::Depth,
498        ) -> fidl::Result<()> {
499            encoder.debug_check_bounds::<SuspendResult>(offset);
500            // Vector header
501            let max_ordinal: u64 = self.max_ordinal_present();
502            encoder.write_num(max_ordinal, offset);
503            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
504            // Calling encoder.out_of_line_offset(0) is not allowed.
505            if max_ordinal == 0 {
506                return Ok(());
507            }
508            depth.increment()?;
509            let envelope_size = 8;
510            let bytes_len = max_ordinal as usize * envelope_size;
511            #[allow(unused_variables)]
512            let offset = encoder.out_of_line_offset(bytes_len);
513            let mut _prev_end_offset: usize = 0;
514            if 1 > max_ordinal {
515                return Ok(());
516            }
517
518            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
519            // are envelope_size bytes.
520            let cur_offset: usize = (1 - 1) * envelope_size;
521
522            // Zero reserved fields.
523            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
524
525            // Safety:
526            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
527            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
528            //   envelope_size bytes, there is always sufficient room.
529            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_power_suspend__common::WakeReason, D>(
530            self.reason.as_ref().map(<fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::ValueTypeMarker>::borrow),
531            encoder, offset + cur_offset, depth
532        )?;
533
534            _prev_end_offset = cur_offset + envelope_size;
535            if 2 > max_ordinal {
536                return Ok(());
537            }
538
539            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
540            // are envelope_size bytes.
541            let cur_offset: usize = (2 - 1) * envelope_size;
542
543            // Zero reserved fields.
544            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
545
546            // Safety:
547            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
548            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
549            //   envelope_size bytes, there is always sufficient room.
550            fidl::encoding::encode_in_envelope_optional::<i64, D>(
551                self.suspend_duration
552                    .as_ref()
553                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
554                encoder,
555                offset + cur_offset,
556                depth,
557            )?;
558
559            _prev_end_offset = cur_offset + envelope_size;
560            if 3 > max_ordinal {
561                return Ok(());
562            }
563
564            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
565            // are envelope_size bytes.
566            let cur_offset: usize = (3 - 1) * envelope_size;
567
568            // Zero reserved fields.
569            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
570
571            // Safety:
572            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
573            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
574            //   envelope_size bytes, there is always sufficient room.
575            fidl::encoding::encode_in_envelope_optional::<i64, D>(
576                self.suspend_overhead
577                    .as_ref()
578                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
579                encoder,
580                offset + cur_offset,
581                depth,
582            )?;
583
584            _prev_end_offset = cur_offset + envelope_size;
585
586            Ok(())
587        }
588    }
589
590    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendResult {
591        #[inline(always)]
592        fn new_empty() -> Self {
593            Self::default()
594        }
595
596        unsafe fn decode(
597            &mut self,
598            decoder: &mut fidl::encoding::Decoder<'_, D>,
599            offset: usize,
600            mut depth: fidl::encoding::Depth,
601        ) -> fidl::Result<()> {
602            decoder.debug_check_bounds::<Self>(offset);
603            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
604                None => return Err(fidl::Error::NotNullable),
605                Some(len) => len,
606            };
607            // Calling decoder.out_of_line_offset(0) is not allowed.
608            if len == 0 {
609                return Ok(());
610            };
611            depth.increment()?;
612            let envelope_size = 8;
613            let bytes_len = len * envelope_size;
614            let offset = decoder.out_of_line_offset(bytes_len)?;
615            // Decode the envelope for each type.
616            let mut _next_ordinal_to_read = 0;
617            let mut next_offset = offset;
618            let end_offset = offset + bytes_len;
619            _next_ordinal_to_read += 1;
620            if next_offset >= end_offset {
621                return Ok(());
622            }
623
624            // Decode unknown envelopes for gaps in ordinals.
625            while _next_ordinal_to_read < 1 {
626                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
627                _next_ordinal_to_read += 1;
628                next_offset += envelope_size;
629            }
630
631            let next_out_of_line = decoder.next_out_of_line();
632            let handles_before = decoder.remaining_handles();
633            if let Some((inlined, num_bytes, num_handles)) =
634                fidl::encoding::decode_envelope_header(decoder, next_offset)?
635            {
636                let member_inline_size = <fidl_fuchsia_hardware_power_suspend__common::WakeReason as fidl::encoding::TypeMarker>::inline_size(decoder.context);
637                if inlined != (member_inline_size <= 4) {
638                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
639                }
640                let inner_offset;
641                let mut inner_depth = depth.clone();
642                if inlined {
643                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
644                    inner_offset = next_offset;
645                } else {
646                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
647                    inner_depth.increment()?;
648                }
649                let val_ref = self.reason.get_or_insert_with(|| {
650                    fidl::new_empty!(fidl_fuchsia_hardware_power_suspend__common::WakeReason, D)
651                });
652                fidl::decode!(
653                    fidl_fuchsia_hardware_power_suspend__common::WakeReason,
654                    D,
655                    val_ref,
656                    decoder,
657                    inner_offset,
658                    inner_depth
659                )?;
660                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
661                {
662                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
663                }
664                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
665                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
666                }
667            }
668
669            next_offset += envelope_size;
670            _next_ordinal_to_read += 1;
671            if next_offset >= end_offset {
672                return Ok(());
673            }
674
675            // Decode unknown envelopes for gaps in ordinals.
676            while _next_ordinal_to_read < 2 {
677                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
678                _next_ordinal_to_read += 1;
679                next_offset += envelope_size;
680            }
681
682            let next_out_of_line = decoder.next_out_of_line();
683            let handles_before = decoder.remaining_handles();
684            if let Some((inlined, num_bytes, num_handles)) =
685                fidl::encoding::decode_envelope_header(decoder, next_offset)?
686            {
687                let member_inline_size =
688                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
689                if inlined != (member_inline_size <= 4) {
690                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
691                }
692                let inner_offset;
693                let mut inner_depth = depth.clone();
694                if inlined {
695                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
696                    inner_offset = next_offset;
697                } else {
698                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
699                    inner_depth.increment()?;
700                }
701                let val_ref = self.suspend_duration.get_or_insert_with(|| fidl::new_empty!(i64, D));
702                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
703                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
704                {
705                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
706                }
707                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
708                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
709                }
710            }
711
712            next_offset += envelope_size;
713            _next_ordinal_to_read += 1;
714            if next_offset >= end_offset {
715                return Ok(());
716            }
717
718            // Decode unknown envelopes for gaps in ordinals.
719            while _next_ordinal_to_read < 3 {
720                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
721                _next_ordinal_to_read += 1;
722                next_offset += envelope_size;
723            }
724
725            let next_out_of_line = decoder.next_out_of_line();
726            let handles_before = decoder.remaining_handles();
727            if let Some((inlined, num_bytes, num_handles)) =
728                fidl::encoding::decode_envelope_header(decoder, next_offset)?
729            {
730                let member_inline_size =
731                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
732                if inlined != (member_inline_size <= 4) {
733                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
734                }
735                let inner_offset;
736                let mut inner_depth = depth.clone();
737                if inlined {
738                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
739                    inner_offset = next_offset;
740                } else {
741                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
742                    inner_depth.increment()?;
743                }
744                let val_ref = self.suspend_overhead.get_or_insert_with(|| fidl::new_empty!(i64, D));
745                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
746                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
747                {
748                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
749                }
750                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
751                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
752                }
753            }
754
755            next_offset += envelope_size;
756
757            // Decode the remaining unknown envelopes.
758            while next_offset < end_offset {
759                _next_ordinal_to_read += 1;
760                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
761                next_offset += envelope_size;
762            }
763
764            Ok(())
765        }
766    }
767
768    impl fidl::encoding::ValueTypeMarker for DeviceResumeRequest {
769        type Borrowed<'a> = &'a Self;
770        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
771            value
772        }
773    }
774
775    unsafe impl fidl::encoding::TypeMarker for DeviceResumeRequest {
776        type Owned = Self;
777
778        #[inline(always)]
779        fn inline_align(_context: fidl::encoding::Context) -> usize {
780            8
781        }
782
783        #[inline(always)]
784        fn inline_size(_context: fidl::encoding::Context) -> usize {
785            16
786        }
787    }
788
789    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceResumeRequest, D>
790        for &DeviceResumeRequest
791    {
792        #[inline]
793        unsafe fn encode(
794            self,
795            encoder: &mut fidl::encoding::Encoder<'_, D>,
796            offset: usize,
797            _depth: fidl::encoding::Depth,
798        ) -> fidl::Result<()> {
799            encoder.debug_check_bounds::<DeviceResumeRequest>(offset);
800            encoder.write_num::<u64>(self.ordinal(), offset);
801            match self {
802                DeviceResumeRequest::Result(ref val) => {
803                    fidl::encoding::encode_in_envelope::<SuspendResult, D>(
804                        <SuspendResult as fidl::encoding::ValueTypeMarker>::borrow(val),
805                        encoder,
806                        offset + 8,
807                        _depth,
808                    )
809                }
810                DeviceResumeRequest::Error(ref val) => {
811                    fidl::encoding::encode_in_envelope::<i32, D>(
812                        <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
813                        encoder,
814                        offset + 8,
815                        _depth,
816                    )
817                }
818                DeviceResumeRequest::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
819            }
820        }
821    }
822
823    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceResumeRequest {
824        #[inline(always)]
825        fn new_empty() -> Self {
826            Self::__SourceBreaking { unknown_ordinal: 0 }
827        }
828
829        #[inline]
830        unsafe fn decode(
831            &mut self,
832            decoder: &mut fidl::encoding::Decoder<'_, D>,
833            offset: usize,
834            mut depth: fidl::encoding::Depth,
835        ) -> fidl::Result<()> {
836            decoder.debug_check_bounds::<Self>(offset);
837            #[allow(unused_variables)]
838            let next_out_of_line = decoder.next_out_of_line();
839            let handles_before = decoder.remaining_handles();
840            let (ordinal, inlined, num_bytes, num_handles) =
841                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
842
843            let member_inline_size = match ordinal {
844                1 => <SuspendResult as fidl::encoding::TypeMarker>::inline_size(decoder.context),
845                2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
846                0 => return Err(fidl::Error::UnknownUnionTag),
847                _ => num_bytes as usize,
848            };
849
850            if inlined != (member_inline_size <= 4) {
851                return Err(fidl::Error::InvalidInlineBitInEnvelope);
852            }
853            let _inner_offset;
854            if inlined {
855                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
856                _inner_offset = offset + 8;
857            } else {
858                depth.increment()?;
859                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
860            }
861            match ordinal {
862                1 => {
863                    #[allow(irrefutable_let_patterns)]
864                    if let DeviceResumeRequest::Result(_) = self {
865                        // Do nothing, read the value into the object
866                    } else {
867                        // Initialize `self` to the right variant
868                        *self = DeviceResumeRequest::Result(fidl::new_empty!(SuspendResult, D));
869                    }
870                    #[allow(irrefutable_let_patterns)]
871                    if let DeviceResumeRequest::Result(ref mut val) = self {
872                        fidl::decode!(SuspendResult, D, val, decoder, _inner_offset, depth)?;
873                    } else {
874                        unreachable!()
875                    }
876                }
877                2 => {
878                    #[allow(irrefutable_let_patterns)]
879                    if let DeviceResumeRequest::Error(_) = self {
880                        // Do nothing, read the value into the object
881                    } else {
882                        // Initialize `self` to the right variant
883                        *self = DeviceResumeRequest::Error(fidl::new_empty!(i32, D));
884                    }
885                    #[allow(irrefutable_let_patterns)]
886                    if let DeviceResumeRequest::Error(ref mut val) = self {
887                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
888                    } else {
889                        unreachable!()
890                    }
891                }
892                #[allow(deprecated)]
893                ordinal => {
894                    for _ in 0..num_handles {
895                        decoder.drop_next_handle()?;
896                    }
897                    *self = DeviceResumeRequest::__SourceBreaking { unknown_ordinal: ordinal };
898                }
899            }
900            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
901                return Err(fidl::Error::InvalidNumBytesInEnvelope);
902            }
903            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
904                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
905            }
906            Ok(())
907        }
908    }
909}