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