1#![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
11pub const MAX_REBOOT_REASONS: u8 = 100;
14
15pub const MAX_REBOOT_WATCHER_RESPONSE_TIME_SECONDS: u32 = 5;
18
19#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
23#[repr(u32)]
24pub enum RebootReason {
25 UserRequest = 1,
26 SystemUpdate = 2,
28 RetrySystemUpdate = 8,
30 HighTemperature = 3,
31 FactoryDataReset = 6,
32 SessionFailure = 4,
34 SysmgrFailure = 5,
36 CriticalComponentFailure = 7,
38 ZbiSwap = 9,
40 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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
70pub enum RebootReason2 {
71 UserRequest,
72 SystemUpdate,
74 RetrySystemUpdate,
76 HighTemperature,
77 FactoryDataReset,
78 SessionFailure,
80 SysmgrFailure,
82 CriticalComponentFailure,
84 ZbiSwap,
86 OutOfMemory,
88 NetstackMigration,
90 #[doc(hidden)]
91 __SourceBreaking {
92 unknown_ordinal: u32,
93 },
94}
95
96#[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#[derive(Clone, Debug, Default, PartialEq)]
203pub struct RebootOptions {
204 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
761
762 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
764
765 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 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 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 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 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}