fidl_fuchsia_hardware_power_statecontrol__common/
fidl_fuchsia_hardware_power_statecontrol__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/// The maximum number of reboot reasons that can be attributed to a single
12/// reboot request.
13pub const MAX_REBOOT_REASONS: u8 = 100;
14
15/// The maxium number of seconds the server will wait for responses from all RebootMethodsWatchers
16/// before changing the system power state.
17pub const MAX_REBOOT_WATCHER_RESPONSE_TIME_SECONDS: u32 = 5;
18
19/// The maximum number of shutdown reasons that can be attributed to a single
20/// shutdown request.
21pub const MAX_SHUTDOWN_REASONS: u8 = 100;
22
23/// The maximum number of seconds the server will wait for responses from all ShutdownWatchers
24/// before changing the system power state.
25pub const MAX_SHUTDOWN_WATCHER_RESPONSE_TIME_SECONDS: u32 = 5;
26
27/// The maximum number of seconds the server will wait for responses from all TerminalStateWatchers
28/// before changing the system power state.
29pub const MAX_TERMINAL_STATE_WATCHER_RESPONSE_TIME_SECONDS: u32 = 5;
30
31/// Why the system reboots.
32///
33/// Replaced by `ShutdownReason`.
34#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
35pub enum RebootReason2 {
36    /// The device rebooted because the end user of the device initiated the reboot.
37    ///
38    /// DO NOT USE for any code path not directly related to an end user explicit reboot action.
39    /// Use DEVELOPER_REQUEST below instead.
40    UserRequest,
41    /// The device rebooted because a developer initiated the reboot, typically via a shell command
42    /// or similar interface, including within an automated test.
43    DeveloperRequest,
44    /// A new system update has been downloaded.
45    SystemUpdate,
46    /// Applying the system update has failed.
47    RetrySystemUpdate,
48    HighTemperature,
49    FactoryDataReset,
50    /// Sessionmgr has failed.
51    SessionFailure,
52    /// sysmgr crashed.
53    SysmgrFailure,
54    /// A critical system component has failed.
55    CriticalComponentFailure,
56    /// A boot partition change was effected.
57    ZbiSwap,
58    /// The system hit a critical low threshold of available memory.
59    OutOfMemory,
60    /// The Netstack component is changing versions.
61    NetstackMigration,
62    /// An Android-initiated reboot reason that Starnix doesn't recognize
63    AndroidUnexpectedReason,
64    /// Android called for the "RescueParty".
65    AndroidRescueParty,
66    /// A critical Android process failed.
67    AndroidCriticalProcessFailure,
68    #[doc(hidden)]
69    __SourceBreaking {
70        unknown_ordinal: u32,
71    },
72}
73
74/// Pattern that matches an unknown `RebootReason2` member.
75#[macro_export]
76macro_rules! RebootReason2Unknown {
77    () => {
78        _
79    };
80}
81
82impl RebootReason2 {
83    #[inline]
84    pub fn from_primitive(prim: u32) -> Option<Self> {
85        match prim {
86            1 => Some(Self::UserRequest),
87            13 => Some(Self::DeveloperRequest),
88            2 => Some(Self::SystemUpdate),
89            8 => Some(Self::RetrySystemUpdate),
90            3 => Some(Self::HighTemperature),
91            6 => Some(Self::FactoryDataReset),
92            4 => Some(Self::SessionFailure),
93            5 => Some(Self::SysmgrFailure),
94            7 => Some(Self::CriticalComponentFailure),
95            9 => Some(Self::ZbiSwap),
96            10 => Some(Self::OutOfMemory),
97            11 => Some(Self::NetstackMigration),
98            12 => Some(Self::AndroidUnexpectedReason),
99            14 => Some(Self::AndroidRescueParty),
100            15 => Some(Self::AndroidCriticalProcessFailure),
101            _ => None,
102        }
103    }
104
105    #[inline]
106    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
107        match prim {
108            1 => Self::UserRequest,
109            13 => Self::DeveloperRequest,
110            2 => Self::SystemUpdate,
111            8 => Self::RetrySystemUpdate,
112            3 => Self::HighTemperature,
113            6 => Self::FactoryDataReset,
114            4 => Self::SessionFailure,
115            5 => Self::SysmgrFailure,
116            7 => Self::CriticalComponentFailure,
117            9 => Self::ZbiSwap,
118            10 => Self::OutOfMemory,
119            11 => Self::NetstackMigration,
120            12 => Self::AndroidUnexpectedReason,
121            14 => Self::AndroidRescueParty,
122            15 => Self::AndroidCriticalProcessFailure,
123            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
124        }
125    }
126
127    #[inline]
128    pub fn unknown() -> Self {
129        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
130    }
131
132    #[inline]
133    pub const fn into_primitive(self) -> u32 {
134        match self {
135            Self::UserRequest => 1,
136            Self::DeveloperRequest => 13,
137            Self::SystemUpdate => 2,
138            Self::RetrySystemUpdate => 8,
139            Self::HighTemperature => 3,
140            Self::FactoryDataReset => 6,
141            Self::SessionFailure => 4,
142            Self::SysmgrFailure => 5,
143            Self::CriticalComponentFailure => 7,
144            Self::ZbiSwap => 9,
145            Self::OutOfMemory => 10,
146            Self::NetstackMigration => 11,
147            Self::AndroidUnexpectedReason => 12,
148            Self::AndroidRescueParty => 14,
149            Self::AndroidCriticalProcessFailure => 15,
150            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
151        }
152    }
153
154    #[inline]
155    pub fn is_unknown(&self) -> bool {
156        match self {
157            Self::__SourceBreaking { unknown_ordinal: _ } => true,
158            _ => false,
159        }
160    }
161}
162
163#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
164pub enum ShutdownAction {
165    Poweroff,
166    Reboot,
167    RebootToRecovery,
168    RebootToBootloader,
169    #[doc(hidden)]
170    __SourceBreaking {
171        unknown_ordinal: u32,
172    },
173}
174
175/// Pattern that matches an unknown `ShutdownAction` member.
176#[macro_export]
177macro_rules! ShutdownActionUnknown {
178    () => {
179        _
180    };
181}
182
183impl ShutdownAction {
184    #[inline]
185    pub fn from_primitive(prim: u32) -> Option<Self> {
186        match prim {
187            1 => Some(Self::Poweroff),
188            2 => Some(Self::Reboot),
189            3 => Some(Self::RebootToRecovery),
190            4 => Some(Self::RebootToBootloader),
191            _ => None,
192        }
193    }
194
195    #[inline]
196    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
197        match prim {
198            1 => Self::Poweroff,
199            2 => Self::Reboot,
200            3 => Self::RebootToRecovery,
201            4 => Self::RebootToBootloader,
202            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
203        }
204    }
205
206    #[inline]
207    pub fn unknown() -> Self {
208        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
209    }
210
211    #[inline]
212    pub const fn into_primitive(self) -> u32 {
213        match self {
214            Self::Poweroff => 1,
215            Self::Reboot => 2,
216            Self::RebootToRecovery => 3,
217            Self::RebootToBootloader => 4,
218            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
219        }
220    }
221
222    #[inline]
223    pub fn is_unknown(&self) -> bool {
224        match self {
225            Self::__SourceBreaking { unknown_ordinal: _ } => true,
226            _ => false,
227        }
228    }
229}
230
231/// Why the system is shutting down.
232#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
233pub enum ShutdownReason {
234    /// The end user of the device initiated the shutdown.
235    ///
236    /// DO NOT USE for any code path not directly related to an end user explicit shutdown action.
237    /// Use DEVELOPER_REQUEST below instead.
238    UserRequest,
239    /// The end user of the device initiated the shutdown because the device was stuck.
240    UserRequestDeviceStuck,
241    /// The developer initiated the shutdown, typically via a shell command or similar interface,
242    /// including within an automated test.
243    DeveloperRequest,
244    /// A new system update has been downloaded.
245    SystemUpdate,
246    /// Applying the system update has failed.
247    RetrySystemUpdate,
248    /// The device has crossed the high temperature threshold.
249    HighTemperature,
250    /// The device is about to perform an FDR.
251    FactoryDataReset,
252    /// Sessionmgr has failed.
253    SessionFailure,
254    /// A critical system component has failed.
255    CriticalComponentFailure,
256    /// A boot partition change was effected.
257    ZbiSwap,
258    /// The system hit a critical low threshold of available memory.
259    OutOfMemory,
260    /// The Netstack component is changing versions.
261    NetstackMigration,
262    /// An Android-initiated shutdown reason that Starnix doesn't recognize.
263    AndroidUnexpectedReason,
264    /// A Starnix container initiated the shutdown but Starnix doesn't know why.
265    StarnixContainerNoReason,
266    /// Android called for the "RescueParty".
267    AndroidRescueParty,
268    /// A critical Android process failed.
269    AndroidCriticalProcessFailure,
270    /// The device battery is drained.
271    BatteryDrained,
272    /// The system failed to suspend or resume within the expected time.
273    SuspensionFailure,
274    #[doc(hidden)]
275    __SourceBreaking { unknown_ordinal: u32 },
276}
277
278/// Pattern that matches an unknown `ShutdownReason` member.
279#[macro_export]
280macro_rules! ShutdownReasonUnknown {
281    () => {
282        _
283    };
284}
285
286impl ShutdownReason {
287    #[inline]
288    pub fn from_primitive(prim: u32) -> Option<Self> {
289        match prim {
290            1 => Some(Self::UserRequest),
291            16 => Some(Self::UserRequestDeviceStuck),
292            2 => Some(Self::DeveloperRequest),
293            3 => Some(Self::SystemUpdate),
294            4 => Some(Self::RetrySystemUpdate),
295            5 => Some(Self::HighTemperature),
296            6 => Some(Self::FactoryDataReset),
297            7 => Some(Self::SessionFailure),
298            8 => Some(Self::CriticalComponentFailure),
299            9 => Some(Self::ZbiSwap),
300            10 => Some(Self::OutOfMemory),
301            11 => Some(Self::NetstackMigration),
302            12 => Some(Self::AndroidUnexpectedReason),
303            15 => Some(Self::StarnixContainerNoReason),
304            13 => Some(Self::AndroidRescueParty),
305            14 => Some(Self::AndroidCriticalProcessFailure),
306            17 => Some(Self::BatteryDrained),
307            18 => Some(Self::SuspensionFailure),
308            _ => None,
309        }
310    }
311
312    #[inline]
313    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
314        match prim {
315            1 => Self::UserRequest,
316            16 => Self::UserRequestDeviceStuck,
317            2 => Self::DeveloperRequest,
318            3 => Self::SystemUpdate,
319            4 => Self::RetrySystemUpdate,
320            5 => Self::HighTemperature,
321            6 => Self::FactoryDataReset,
322            7 => Self::SessionFailure,
323            8 => Self::CriticalComponentFailure,
324            9 => Self::ZbiSwap,
325            10 => Self::OutOfMemory,
326            11 => Self::NetstackMigration,
327            12 => Self::AndroidUnexpectedReason,
328            15 => Self::StarnixContainerNoReason,
329            13 => Self::AndroidRescueParty,
330            14 => Self::AndroidCriticalProcessFailure,
331            17 => Self::BatteryDrained,
332            18 => Self::SuspensionFailure,
333            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
334        }
335    }
336
337    #[inline]
338    pub fn unknown() -> Self {
339        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
340    }
341
342    #[inline]
343    pub const fn into_primitive(self) -> u32 {
344        match self {
345            Self::UserRequest => 1,
346            Self::UserRequestDeviceStuck => 16,
347            Self::DeveloperRequest => 2,
348            Self::SystemUpdate => 3,
349            Self::RetrySystemUpdate => 4,
350            Self::HighTemperature => 5,
351            Self::FactoryDataReset => 6,
352            Self::SessionFailure => 7,
353            Self::CriticalComponentFailure => 8,
354            Self::ZbiSwap => 9,
355            Self::OutOfMemory => 10,
356            Self::NetstackMigration => 11,
357            Self::AndroidUnexpectedReason => 12,
358            Self::StarnixContainerNoReason => 15,
359            Self::AndroidRescueParty => 13,
360            Self::AndroidCriticalProcessFailure => 14,
361            Self::BatteryDrained => 17,
362            Self::SuspensionFailure => 18,
363            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
364        }
365    }
366
367    #[inline]
368    pub fn is_unknown(&self) -> bool {
369        match self {
370            Self::__SourceBreaking { unknown_ordinal: _ } => true,
371            _ => false,
372        }
373    }
374}
375
376#[derive(Clone, Debug, PartialEq)]
377pub struct AdminPerformRebootRequest {
378    pub options: RebootOptions,
379}
380
381impl fidl::Persistable for AdminPerformRebootRequest {}
382
383#[derive(Clone, Debug, PartialEq)]
384pub struct AdminShutdownRequest {
385    pub options: ShutdownOptions,
386}
387
388impl fidl::Persistable for AdminShutdownRequest {}
389
390#[derive(Clone, Debug, PartialEq)]
391pub struct RebootWatcherOnRebootRequest {
392    pub options: RebootOptions,
393}
394
395impl fidl::Persistable for RebootWatcherOnRebootRequest {}
396
397#[derive(Clone, Debug, PartialEq)]
398pub struct ShutdownWatcherOnShutdownRequest {
399    pub options: ShutdownOptions,
400}
401
402impl fidl::Persistable for ShutdownWatcherOnShutdownRequest {}
403
404/// The options specified when a reboot is requested.
405#[derive(Clone, Debug, Default, PartialEq)]
406pub struct RebootOptions {
407    /// The set of reboot reasons that are responsible for this reboot request.
408    pub reasons: Option<Vec<RebootReason2>>,
409    #[doc(hidden)]
410    pub __source_breaking: fidl::marker::SourceBreaking,
411}
412
413impl fidl::Persistable for RebootOptions {}
414
415/// The options specified when a shutdown is requested.
416#[derive(Clone, Debug, Default, PartialEq)]
417pub struct ShutdownOptions {
418    pub action: Option<ShutdownAction>,
419    /// The set of shutdown reasons that are responsible for this shutdown request.
420    pub reasons: Option<Vec<ShutdownReason>>,
421    #[doc(hidden)]
422    pub __source_breaking: fidl::marker::SourceBreaking,
423}
424
425impl fidl::Persistable for ShutdownOptions {}
426
427pub mod admin_ordinals {
428    pub const POWER_FULLY_ON: u64 = 0xb3272d15e00712f;
429    pub const SHUTDOWN: u64 = 0x3722c53e45dc022f;
430    pub const PERFORM_REBOOT: u64 = 0x9416b4d36a80b4;
431    pub const REBOOT_TO_BOOTLOADER: u64 = 0x6dce331b33786aa;
432    pub const REBOOT_TO_RECOVERY: u64 = 0x1575c566be54f505;
433    pub const POWEROFF: u64 = 0x24101c5d0b439748;
434    pub const MEXEC: u64 = 0x1f91e77ec781a4c6;
435    pub const SUSPEND_TO_RAM: u64 = 0x3b0e356782e7620e;
436}
437
438pub mod reboot_methods_watcher_register_ordinals {
439    pub const REGISTER_WATCHER: u64 = 0x3e6610e78471238;
440}
441
442pub mod reboot_watcher_ordinals {
443    pub const ON_REBOOT: u64 = 0x5334bbbe774f13c3;
444}
445
446pub mod shutdown_watcher_ordinals {
447    pub const ON_SHUTDOWN: u64 = 0x1d9467990d7dc6db;
448}
449
450pub mod shutdown_watcher_register_ordinals {
451    pub const REGISTER_WATCHER: u64 = 0x3db6ce5d34810aff;
452    pub const REGISTER_TERMINAL_STATE_WATCHER: u64 = 0x1cce7216bb7869fc;
453}
454
455pub mod terminal_state_watcher_ordinals {
456    pub const ON_TERMINAL_STATE_TRANSITION_STARTED: u64 = 0x25d95d9d1ae60f10;
457}
458
459mod internal {
460    use super::*;
461    unsafe impl fidl::encoding::TypeMarker for RebootReason2 {
462        type Owned = Self;
463
464        #[inline(always)]
465        fn inline_align(_context: fidl::encoding::Context) -> usize {
466            std::mem::align_of::<u32>()
467        }
468
469        #[inline(always)]
470        fn inline_size(_context: fidl::encoding::Context) -> usize {
471            std::mem::size_of::<u32>()
472        }
473
474        #[inline(always)]
475        fn encode_is_copy() -> bool {
476            false
477        }
478
479        #[inline(always)]
480        fn decode_is_copy() -> bool {
481            false
482        }
483    }
484
485    impl fidl::encoding::ValueTypeMarker for RebootReason2 {
486        type Borrowed<'a> = Self;
487        #[inline(always)]
488        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
489            *value
490        }
491    }
492
493    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for RebootReason2 {
494        #[inline]
495        unsafe fn encode(
496            self,
497            encoder: &mut fidl::encoding::Encoder<'_, D>,
498            offset: usize,
499            _depth: fidl::encoding::Depth,
500        ) -> fidl::Result<()> {
501            encoder.debug_check_bounds::<Self>(offset);
502            encoder.write_num(self.into_primitive(), offset);
503            Ok(())
504        }
505    }
506
507    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RebootReason2 {
508        #[inline(always)]
509        fn new_empty() -> Self {
510            Self::unknown()
511        }
512
513        #[inline]
514        unsafe fn decode(
515            &mut self,
516            decoder: &mut fidl::encoding::Decoder<'_, D>,
517            offset: usize,
518            _depth: fidl::encoding::Depth,
519        ) -> fidl::Result<()> {
520            decoder.debug_check_bounds::<Self>(offset);
521            let prim = decoder.read_num::<u32>(offset);
522
523            *self = Self::from_primitive_allow_unknown(prim);
524            Ok(())
525        }
526    }
527    unsafe impl fidl::encoding::TypeMarker for ShutdownAction {
528        type Owned = Self;
529
530        #[inline(always)]
531        fn inline_align(_context: fidl::encoding::Context) -> usize {
532            std::mem::align_of::<u32>()
533        }
534
535        #[inline(always)]
536        fn inline_size(_context: fidl::encoding::Context) -> usize {
537            std::mem::size_of::<u32>()
538        }
539
540        #[inline(always)]
541        fn encode_is_copy() -> bool {
542            false
543        }
544
545        #[inline(always)]
546        fn decode_is_copy() -> bool {
547            false
548        }
549    }
550
551    impl fidl::encoding::ValueTypeMarker for ShutdownAction {
552        type Borrowed<'a> = Self;
553        #[inline(always)]
554        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
555            *value
556        }
557    }
558
559    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ShutdownAction {
560        #[inline]
561        unsafe fn encode(
562            self,
563            encoder: &mut fidl::encoding::Encoder<'_, D>,
564            offset: usize,
565            _depth: fidl::encoding::Depth,
566        ) -> fidl::Result<()> {
567            encoder.debug_check_bounds::<Self>(offset);
568            encoder.write_num(self.into_primitive(), offset);
569            Ok(())
570        }
571    }
572
573    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ShutdownAction {
574        #[inline(always)]
575        fn new_empty() -> Self {
576            Self::unknown()
577        }
578
579        #[inline]
580        unsafe fn decode(
581            &mut self,
582            decoder: &mut fidl::encoding::Decoder<'_, D>,
583            offset: usize,
584            _depth: fidl::encoding::Depth,
585        ) -> fidl::Result<()> {
586            decoder.debug_check_bounds::<Self>(offset);
587            let prim = decoder.read_num::<u32>(offset);
588
589            *self = Self::from_primitive_allow_unknown(prim);
590            Ok(())
591        }
592    }
593    unsafe impl fidl::encoding::TypeMarker for ShutdownReason {
594        type Owned = Self;
595
596        #[inline(always)]
597        fn inline_align(_context: fidl::encoding::Context) -> usize {
598            std::mem::align_of::<u32>()
599        }
600
601        #[inline(always)]
602        fn inline_size(_context: fidl::encoding::Context) -> usize {
603            std::mem::size_of::<u32>()
604        }
605
606        #[inline(always)]
607        fn encode_is_copy() -> bool {
608            false
609        }
610
611        #[inline(always)]
612        fn decode_is_copy() -> bool {
613            false
614        }
615    }
616
617    impl fidl::encoding::ValueTypeMarker for ShutdownReason {
618        type Borrowed<'a> = Self;
619        #[inline(always)]
620        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
621            *value
622        }
623    }
624
625    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ShutdownReason {
626        #[inline]
627        unsafe fn encode(
628            self,
629            encoder: &mut fidl::encoding::Encoder<'_, D>,
630            offset: usize,
631            _depth: fidl::encoding::Depth,
632        ) -> fidl::Result<()> {
633            encoder.debug_check_bounds::<Self>(offset);
634            encoder.write_num(self.into_primitive(), offset);
635            Ok(())
636        }
637    }
638
639    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ShutdownReason {
640        #[inline(always)]
641        fn new_empty() -> Self {
642            Self::unknown()
643        }
644
645        #[inline]
646        unsafe fn decode(
647            &mut self,
648            decoder: &mut fidl::encoding::Decoder<'_, D>,
649            offset: usize,
650            _depth: fidl::encoding::Depth,
651        ) -> fidl::Result<()> {
652            decoder.debug_check_bounds::<Self>(offset);
653            let prim = decoder.read_num::<u32>(offset);
654
655            *self = Self::from_primitive_allow_unknown(prim);
656            Ok(())
657        }
658    }
659
660    impl fidl::encoding::ValueTypeMarker for AdminPerformRebootRequest {
661        type Borrowed<'a> = &'a Self;
662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
663            value
664        }
665    }
666
667    unsafe impl fidl::encoding::TypeMarker for AdminPerformRebootRequest {
668        type Owned = Self;
669
670        #[inline(always)]
671        fn inline_align(_context: fidl::encoding::Context) -> usize {
672            8
673        }
674
675        #[inline(always)]
676        fn inline_size(_context: fidl::encoding::Context) -> usize {
677            16
678        }
679    }
680
681    unsafe impl<D: fidl::encoding::ResourceDialect>
682        fidl::encoding::Encode<AdminPerformRebootRequest, D> for &AdminPerformRebootRequest
683    {
684        #[inline]
685        unsafe fn encode(
686            self,
687            encoder: &mut fidl::encoding::Encoder<'_, D>,
688            offset: usize,
689            _depth: fidl::encoding::Depth,
690        ) -> fidl::Result<()> {
691            encoder.debug_check_bounds::<AdminPerformRebootRequest>(offset);
692            // Delegate to tuple encoding.
693            fidl::encoding::Encode::<AdminPerformRebootRequest, D>::encode(
694                (<RebootOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
695                encoder,
696                offset,
697                _depth,
698            )
699        }
700    }
701    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RebootOptions, D>>
702        fidl::encoding::Encode<AdminPerformRebootRequest, D> for (T0,)
703    {
704        #[inline]
705        unsafe fn encode(
706            self,
707            encoder: &mut fidl::encoding::Encoder<'_, D>,
708            offset: usize,
709            depth: fidl::encoding::Depth,
710        ) -> fidl::Result<()> {
711            encoder.debug_check_bounds::<AdminPerformRebootRequest>(offset);
712            // Zero out padding regions. There's no need to apply masks
713            // because the unmasked parts will be overwritten by fields.
714            // Write the fields.
715            self.0.encode(encoder, offset + 0, depth)?;
716            Ok(())
717        }
718    }
719
720    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
721        for AdminPerformRebootRequest
722    {
723        #[inline(always)]
724        fn new_empty() -> Self {
725            Self { options: fidl::new_empty!(RebootOptions, D) }
726        }
727
728        #[inline]
729        unsafe fn decode(
730            &mut self,
731            decoder: &mut fidl::encoding::Decoder<'_, D>,
732            offset: usize,
733            _depth: fidl::encoding::Depth,
734        ) -> fidl::Result<()> {
735            decoder.debug_check_bounds::<Self>(offset);
736            // Verify that padding bytes are zero.
737            fidl::decode!(RebootOptions, D, &mut self.options, decoder, offset + 0, _depth)?;
738            Ok(())
739        }
740    }
741
742    impl fidl::encoding::ValueTypeMarker for AdminShutdownRequest {
743        type Borrowed<'a> = &'a Self;
744        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
745            value
746        }
747    }
748
749    unsafe impl fidl::encoding::TypeMarker for AdminShutdownRequest {
750        type Owned = Self;
751
752        #[inline(always)]
753        fn inline_align(_context: fidl::encoding::Context) -> usize {
754            8
755        }
756
757        #[inline(always)]
758        fn inline_size(_context: fidl::encoding::Context) -> usize {
759            16
760        }
761    }
762
763    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdminShutdownRequest, D>
764        for &AdminShutdownRequest
765    {
766        #[inline]
767        unsafe fn encode(
768            self,
769            encoder: &mut fidl::encoding::Encoder<'_, D>,
770            offset: usize,
771            _depth: fidl::encoding::Depth,
772        ) -> fidl::Result<()> {
773            encoder.debug_check_bounds::<AdminShutdownRequest>(offset);
774            // Delegate to tuple encoding.
775            fidl::encoding::Encode::<AdminShutdownRequest, D>::encode(
776                (<ShutdownOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
777                encoder,
778                offset,
779                _depth,
780            )
781        }
782    }
783    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ShutdownOptions, D>>
784        fidl::encoding::Encode<AdminShutdownRequest, D> for (T0,)
785    {
786        #[inline]
787        unsafe fn encode(
788            self,
789            encoder: &mut fidl::encoding::Encoder<'_, D>,
790            offset: usize,
791            depth: fidl::encoding::Depth,
792        ) -> fidl::Result<()> {
793            encoder.debug_check_bounds::<AdminShutdownRequest>(offset);
794            // Zero out padding regions. There's no need to apply masks
795            // because the unmasked parts will be overwritten by fields.
796            // Write the fields.
797            self.0.encode(encoder, offset + 0, depth)?;
798            Ok(())
799        }
800    }
801
802    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdminShutdownRequest {
803        #[inline(always)]
804        fn new_empty() -> Self {
805            Self { options: fidl::new_empty!(ShutdownOptions, D) }
806        }
807
808        #[inline]
809        unsafe fn decode(
810            &mut self,
811            decoder: &mut fidl::encoding::Decoder<'_, D>,
812            offset: usize,
813            _depth: fidl::encoding::Depth,
814        ) -> fidl::Result<()> {
815            decoder.debug_check_bounds::<Self>(offset);
816            // Verify that padding bytes are zero.
817            fidl::decode!(ShutdownOptions, D, &mut self.options, decoder, offset + 0, _depth)?;
818            Ok(())
819        }
820    }
821
822    impl fidl::encoding::ValueTypeMarker for RebootWatcherOnRebootRequest {
823        type Borrowed<'a> = &'a Self;
824        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
825            value
826        }
827    }
828
829    unsafe impl fidl::encoding::TypeMarker for RebootWatcherOnRebootRequest {
830        type Owned = Self;
831
832        #[inline(always)]
833        fn inline_align(_context: fidl::encoding::Context) -> usize {
834            8
835        }
836
837        #[inline(always)]
838        fn inline_size(_context: fidl::encoding::Context) -> usize {
839            16
840        }
841    }
842
843    unsafe impl<D: fidl::encoding::ResourceDialect>
844        fidl::encoding::Encode<RebootWatcherOnRebootRequest, D> for &RebootWatcherOnRebootRequest
845    {
846        #[inline]
847        unsafe fn encode(
848            self,
849            encoder: &mut fidl::encoding::Encoder<'_, D>,
850            offset: usize,
851            _depth: fidl::encoding::Depth,
852        ) -> fidl::Result<()> {
853            encoder.debug_check_bounds::<RebootWatcherOnRebootRequest>(offset);
854            // Delegate to tuple encoding.
855            fidl::encoding::Encode::<RebootWatcherOnRebootRequest, D>::encode(
856                (<RebootOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
857                encoder,
858                offset,
859                _depth,
860            )
861        }
862    }
863    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RebootOptions, D>>
864        fidl::encoding::Encode<RebootWatcherOnRebootRequest, D> for (T0,)
865    {
866        #[inline]
867        unsafe fn encode(
868            self,
869            encoder: &mut fidl::encoding::Encoder<'_, D>,
870            offset: usize,
871            depth: fidl::encoding::Depth,
872        ) -> fidl::Result<()> {
873            encoder.debug_check_bounds::<RebootWatcherOnRebootRequest>(offset);
874            // Zero out padding regions. There's no need to apply masks
875            // because the unmasked parts will be overwritten by fields.
876            // Write the fields.
877            self.0.encode(encoder, offset + 0, depth)?;
878            Ok(())
879        }
880    }
881
882    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
883        for RebootWatcherOnRebootRequest
884    {
885        #[inline(always)]
886        fn new_empty() -> Self {
887            Self { options: fidl::new_empty!(RebootOptions, D) }
888        }
889
890        #[inline]
891        unsafe fn decode(
892            &mut self,
893            decoder: &mut fidl::encoding::Decoder<'_, D>,
894            offset: usize,
895            _depth: fidl::encoding::Depth,
896        ) -> fidl::Result<()> {
897            decoder.debug_check_bounds::<Self>(offset);
898            // Verify that padding bytes are zero.
899            fidl::decode!(RebootOptions, D, &mut self.options, decoder, offset + 0, _depth)?;
900            Ok(())
901        }
902    }
903
904    impl fidl::encoding::ValueTypeMarker for ShutdownWatcherOnShutdownRequest {
905        type Borrowed<'a> = &'a Self;
906        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
907            value
908        }
909    }
910
911    unsafe impl fidl::encoding::TypeMarker for ShutdownWatcherOnShutdownRequest {
912        type Owned = Self;
913
914        #[inline(always)]
915        fn inline_align(_context: fidl::encoding::Context) -> usize {
916            8
917        }
918
919        #[inline(always)]
920        fn inline_size(_context: fidl::encoding::Context) -> usize {
921            16
922        }
923    }
924
925    unsafe impl<D: fidl::encoding::ResourceDialect>
926        fidl::encoding::Encode<ShutdownWatcherOnShutdownRequest, D>
927        for &ShutdownWatcherOnShutdownRequest
928    {
929        #[inline]
930        unsafe fn encode(
931            self,
932            encoder: &mut fidl::encoding::Encoder<'_, D>,
933            offset: usize,
934            _depth: fidl::encoding::Depth,
935        ) -> fidl::Result<()> {
936            encoder.debug_check_bounds::<ShutdownWatcherOnShutdownRequest>(offset);
937            // Delegate to tuple encoding.
938            fidl::encoding::Encode::<ShutdownWatcherOnShutdownRequest, D>::encode(
939                (<ShutdownOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),),
940                encoder,
941                offset,
942                _depth,
943            )
944        }
945    }
946    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ShutdownOptions, D>>
947        fidl::encoding::Encode<ShutdownWatcherOnShutdownRequest, D> for (T0,)
948    {
949        #[inline]
950        unsafe fn encode(
951            self,
952            encoder: &mut fidl::encoding::Encoder<'_, D>,
953            offset: usize,
954            depth: fidl::encoding::Depth,
955        ) -> fidl::Result<()> {
956            encoder.debug_check_bounds::<ShutdownWatcherOnShutdownRequest>(offset);
957            // Zero out padding regions. There's no need to apply masks
958            // because the unmasked parts will be overwritten by fields.
959            // Write the fields.
960            self.0.encode(encoder, offset + 0, depth)?;
961            Ok(())
962        }
963    }
964
965    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
966        for ShutdownWatcherOnShutdownRequest
967    {
968        #[inline(always)]
969        fn new_empty() -> Self {
970            Self { options: fidl::new_empty!(ShutdownOptions, D) }
971        }
972
973        #[inline]
974        unsafe fn decode(
975            &mut self,
976            decoder: &mut fidl::encoding::Decoder<'_, D>,
977            offset: usize,
978            _depth: fidl::encoding::Depth,
979        ) -> fidl::Result<()> {
980            decoder.debug_check_bounds::<Self>(offset);
981            // Verify that padding bytes are zero.
982            fidl::decode!(ShutdownOptions, D, &mut self.options, decoder, offset + 0, _depth)?;
983            Ok(())
984        }
985    }
986
987    impl RebootOptions {
988        #[inline(always)]
989        fn max_ordinal_present(&self) -> u64 {
990            if let Some(_) = self.reasons {
991                return 1;
992            }
993            0
994        }
995    }
996
997    impl fidl::encoding::ValueTypeMarker for RebootOptions {
998        type Borrowed<'a> = &'a Self;
999        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1000            value
1001        }
1002    }
1003
1004    unsafe impl fidl::encoding::TypeMarker for RebootOptions {
1005        type Owned = Self;
1006
1007        #[inline(always)]
1008        fn inline_align(_context: fidl::encoding::Context) -> usize {
1009            8
1010        }
1011
1012        #[inline(always)]
1013        fn inline_size(_context: fidl::encoding::Context) -> usize {
1014            16
1015        }
1016    }
1017
1018    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RebootOptions, D>
1019        for &RebootOptions
1020    {
1021        unsafe fn encode(
1022            self,
1023            encoder: &mut fidl::encoding::Encoder<'_, D>,
1024            offset: usize,
1025            mut depth: fidl::encoding::Depth,
1026        ) -> fidl::Result<()> {
1027            encoder.debug_check_bounds::<RebootOptions>(offset);
1028            // Vector header
1029            let max_ordinal: u64 = self.max_ordinal_present();
1030            encoder.write_num(max_ordinal, offset);
1031            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1032            // Calling encoder.out_of_line_offset(0) is not allowed.
1033            if max_ordinal == 0 {
1034                return Ok(());
1035            }
1036            depth.increment()?;
1037            let envelope_size = 8;
1038            let bytes_len = max_ordinal as usize * envelope_size;
1039            #[allow(unused_variables)]
1040            let offset = encoder.out_of_line_offset(bytes_len);
1041            let mut _prev_end_offset: usize = 0;
1042            if 1 > max_ordinal {
1043                return Ok(());
1044            }
1045
1046            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1047            // are envelope_size bytes.
1048            let cur_offset: usize = (1 - 1) * envelope_size;
1049
1050            // Zero reserved fields.
1051            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1052
1053            // Safety:
1054            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1055            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1056            //   envelope_size bytes, there is always sufficient room.
1057            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<RebootReason2, 100>, D>(
1058            self.reasons.as_ref().map(<fidl::encoding::Vector<RebootReason2, 100> as fidl::encoding::ValueTypeMarker>::borrow),
1059            encoder, offset + cur_offset, depth
1060        )?;
1061
1062            _prev_end_offset = cur_offset + envelope_size;
1063
1064            Ok(())
1065        }
1066    }
1067
1068    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RebootOptions {
1069        #[inline(always)]
1070        fn new_empty() -> Self {
1071            Self::default()
1072        }
1073
1074        unsafe fn decode(
1075            &mut self,
1076            decoder: &mut fidl::encoding::Decoder<'_, D>,
1077            offset: usize,
1078            mut depth: fidl::encoding::Depth,
1079        ) -> fidl::Result<()> {
1080            decoder.debug_check_bounds::<Self>(offset);
1081            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1082                None => return Err(fidl::Error::NotNullable),
1083                Some(len) => len,
1084            };
1085            // Calling decoder.out_of_line_offset(0) is not allowed.
1086            if len == 0 {
1087                return Ok(());
1088            };
1089            depth.increment()?;
1090            let envelope_size = 8;
1091            let bytes_len = len * envelope_size;
1092            let offset = decoder.out_of_line_offset(bytes_len)?;
1093            // Decode the envelope for each type.
1094            let mut _next_ordinal_to_read = 0;
1095            let mut next_offset = offset;
1096            let end_offset = offset + bytes_len;
1097            _next_ordinal_to_read += 1;
1098            if next_offset >= end_offset {
1099                return Ok(());
1100            }
1101
1102            // Decode unknown envelopes for gaps in ordinals.
1103            while _next_ordinal_to_read < 1 {
1104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1105                _next_ordinal_to_read += 1;
1106                next_offset += envelope_size;
1107            }
1108
1109            let next_out_of_line = decoder.next_out_of_line();
1110            let handles_before = decoder.remaining_handles();
1111            if let Some((inlined, num_bytes, num_handles)) =
1112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1113            {
1114                let member_inline_size = <fidl::encoding::Vector<RebootReason2, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1115                if inlined != (member_inline_size <= 4) {
1116                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1117                }
1118                let inner_offset;
1119                let mut inner_depth = depth.clone();
1120                if inlined {
1121                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1122                    inner_offset = next_offset;
1123                } else {
1124                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1125                    inner_depth.increment()?;
1126                }
1127                let val_ref = self.reasons.get_or_insert_with(
1128                    || fidl::new_empty!(fidl::encoding::Vector<RebootReason2, 100>, D),
1129                );
1130                fidl::decode!(fidl::encoding::Vector<RebootReason2, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
1131                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1132                {
1133                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1134                }
1135                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1136                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1137                }
1138            }
1139
1140            next_offset += envelope_size;
1141
1142            // Decode the remaining unknown envelopes.
1143            while next_offset < end_offset {
1144                _next_ordinal_to_read += 1;
1145                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1146                next_offset += envelope_size;
1147            }
1148
1149            Ok(())
1150        }
1151    }
1152
1153    impl ShutdownOptions {
1154        #[inline(always)]
1155        fn max_ordinal_present(&self) -> u64 {
1156            if let Some(_) = self.reasons {
1157                return 2;
1158            }
1159            if let Some(_) = self.action {
1160                return 1;
1161            }
1162            0
1163        }
1164    }
1165
1166    impl fidl::encoding::ValueTypeMarker for ShutdownOptions {
1167        type Borrowed<'a> = &'a Self;
1168        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1169            value
1170        }
1171    }
1172
1173    unsafe impl fidl::encoding::TypeMarker for ShutdownOptions {
1174        type Owned = Self;
1175
1176        #[inline(always)]
1177        fn inline_align(_context: fidl::encoding::Context) -> usize {
1178            8
1179        }
1180
1181        #[inline(always)]
1182        fn inline_size(_context: fidl::encoding::Context) -> usize {
1183            16
1184        }
1185    }
1186
1187    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ShutdownOptions, D>
1188        for &ShutdownOptions
1189    {
1190        unsafe fn encode(
1191            self,
1192            encoder: &mut fidl::encoding::Encoder<'_, D>,
1193            offset: usize,
1194            mut depth: fidl::encoding::Depth,
1195        ) -> fidl::Result<()> {
1196            encoder.debug_check_bounds::<ShutdownOptions>(offset);
1197            // Vector header
1198            let max_ordinal: u64 = self.max_ordinal_present();
1199            encoder.write_num(max_ordinal, offset);
1200            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1201            // Calling encoder.out_of_line_offset(0) is not allowed.
1202            if max_ordinal == 0 {
1203                return Ok(());
1204            }
1205            depth.increment()?;
1206            let envelope_size = 8;
1207            let bytes_len = max_ordinal as usize * envelope_size;
1208            #[allow(unused_variables)]
1209            let offset = encoder.out_of_line_offset(bytes_len);
1210            let mut _prev_end_offset: usize = 0;
1211            if 1 > max_ordinal {
1212                return Ok(());
1213            }
1214
1215            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1216            // are envelope_size bytes.
1217            let cur_offset: usize = (1 - 1) * envelope_size;
1218
1219            // Zero reserved fields.
1220            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1221
1222            // Safety:
1223            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1224            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1225            //   envelope_size bytes, there is always sufficient room.
1226            fidl::encoding::encode_in_envelope_optional::<ShutdownAction, D>(
1227                self.action
1228                    .as_ref()
1229                    .map(<ShutdownAction as fidl::encoding::ValueTypeMarker>::borrow),
1230                encoder,
1231                offset + cur_offset,
1232                depth,
1233            )?;
1234
1235            _prev_end_offset = cur_offset + envelope_size;
1236            if 2 > max_ordinal {
1237                return Ok(());
1238            }
1239
1240            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1241            // are envelope_size bytes.
1242            let cur_offset: usize = (2 - 1) * envelope_size;
1243
1244            // Zero reserved fields.
1245            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1246
1247            // Safety:
1248            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1249            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1250            //   envelope_size bytes, there is always sufficient room.
1251            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ShutdownReason, 100>, D>(
1252            self.reasons.as_ref().map(<fidl::encoding::Vector<ShutdownReason, 100> as fidl::encoding::ValueTypeMarker>::borrow),
1253            encoder, offset + cur_offset, depth
1254        )?;
1255
1256            _prev_end_offset = cur_offset + envelope_size;
1257
1258            Ok(())
1259        }
1260    }
1261
1262    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ShutdownOptions {
1263        #[inline(always)]
1264        fn new_empty() -> Self {
1265            Self::default()
1266        }
1267
1268        unsafe fn decode(
1269            &mut self,
1270            decoder: &mut fidl::encoding::Decoder<'_, D>,
1271            offset: usize,
1272            mut depth: fidl::encoding::Depth,
1273        ) -> fidl::Result<()> {
1274            decoder.debug_check_bounds::<Self>(offset);
1275            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1276                None => return Err(fidl::Error::NotNullable),
1277                Some(len) => len,
1278            };
1279            // Calling decoder.out_of_line_offset(0) is not allowed.
1280            if len == 0 {
1281                return Ok(());
1282            };
1283            depth.increment()?;
1284            let envelope_size = 8;
1285            let bytes_len = len * envelope_size;
1286            let offset = decoder.out_of_line_offset(bytes_len)?;
1287            // Decode the envelope for each type.
1288            let mut _next_ordinal_to_read = 0;
1289            let mut next_offset = offset;
1290            let end_offset = offset + bytes_len;
1291            _next_ordinal_to_read += 1;
1292            if next_offset >= end_offset {
1293                return Ok(());
1294            }
1295
1296            // Decode unknown envelopes for gaps in ordinals.
1297            while _next_ordinal_to_read < 1 {
1298                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1299                _next_ordinal_to_read += 1;
1300                next_offset += envelope_size;
1301            }
1302
1303            let next_out_of_line = decoder.next_out_of_line();
1304            let handles_before = decoder.remaining_handles();
1305            if let Some((inlined, num_bytes, num_handles)) =
1306                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1307            {
1308                let member_inline_size =
1309                    <ShutdownAction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1310                if inlined != (member_inline_size <= 4) {
1311                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1312                }
1313                let inner_offset;
1314                let mut inner_depth = depth.clone();
1315                if inlined {
1316                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1317                    inner_offset = next_offset;
1318                } else {
1319                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1320                    inner_depth.increment()?;
1321                }
1322                let val_ref =
1323                    self.action.get_or_insert_with(|| fidl::new_empty!(ShutdownAction, D));
1324                fidl::decode!(ShutdownAction, D, val_ref, decoder, inner_offset, inner_depth)?;
1325                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1326                {
1327                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1328                }
1329                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1330                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1331                }
1332            }
1333
1334            next_offset += envelope_size;
1335            _next_ordinal_to_read += 1;
1336            if next_offset >= end_offset {
1337                return Ok(());
1338            }
1339
1340            // Decode unknown envelopes for gaps in ordinals.
1341            while _next_ordinal_to_read < 2 {
1342                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1343                _next_ordinal_to_read += 1;
1344                next_offset += envelope_size;
1345            }
1346
1347            let next_out_of_line = decoder.next_out_of_line();
1348            let handles_before = decoder.remaining_handles();
1349            if let Some((inlined, num_bytes, num_handles)) =
1350                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1351            {
1352                let member_inline_size = <fidl::encoding::Vector<ShutdownReason, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1353                if inlined != (member_inline_size <= 4) {
1354                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1355                }
1356                let inner_offset;
1357                let mut inner_depth = depth.clone();
1358                if inlined {
1359                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1360                    inner_offset = next_offset;
1361                } else {
1362                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1363                    inner_depth.increment()?;
1364                }
1365                let val_ref = self.reasons.get_or_insert_with(
1366                    || fidl::new_empty!(fidl::encoding::Vector<ShutdownReason, 100>, D),
1367                );
1368                fidl::decode!(fidl::encoding::Vector<ShutdownReason, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
1369                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1370                {
1371                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1372                }
1373                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1374                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1375                }
1376            }
1377
1378            next_offset += envelope_size;
1379
1380            // Decode the remaining unknown envelopes.
1381            while next_offset < end_offset {
1382                _next_ordinal_to_read += 1;
1383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1384                next_offset += envelope_size;
1385            }
1386
1387            Ok(())
1388        }
1389    }
1390}
fidl_fuchsia_hardware_power_statecontrol__common/fidl_fuchsia_hardware_power_statecontrol__common.rs

fidl_fuchsia_hardware_power_statecontrol__common/
fidl_fuchsia_hardware_power_statecontrol__common.rs
