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