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 type AttemptId = String;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
15#[repr(u32)]
16pub enum CancelError {
17 NoUpdateInProgress = 1,
19 UpdateCannotBeCanceled = 2,
21 AttemptIdMismatch = 3,
23 CancelLimitExceeded = 4,
25}
26
27impl CancelError {
28 #[inline]
29 pub fn from_primitive(prim: u32) -> Option<Self> {
30 match prim {
31 1 => Some(Self::NoUpdateInProgress),
32 2 => Some(Self::UpdateCannotBeCanceled),
33 3 => Some(Self::AttemptIdMismatch),
34 4 => Some(Self::CancelLimitExceeded),
35 _ => None,
36 }
37 }
38
39 #[inline]
40 pub const fn into_primitive(self) -> u32 {
41 self as u32
42 }
43}
44
45#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
47#[repr(u32)]
48pub enum FetchFailureReason {
49 Internal = 0,
51 OutOfSpace = 1,
53}
54
55impl FetchFailureReason {
56 #[inline]
57 pub fn from_primitive(prim: u32) -> Option<Self> {
58 match prim {
59 0 => Some(Self::Internal),
60 1 => Some(Self::OutOfSpace),
61 _ => None,
62 }
63 }
64
65 #[inline]
66 pub const fn into_primitive(self) -> u32 {
67 self as u32
68 }
69}
70
71#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
73#[repr(u32)]
74pub enum Initiator {
75 User = 0,
78 Service = 1,
80}
81
82impl Initiator {
83 #[inline]
84 pub fn from_primitive(prim: u32) -> Option<Self> {
85 match prim {
86 0 => Some(Self::User),
87 1 => Some(Self::Service),
88 _ => None,
89 }
90 }
91
92 #[inline]
93 pub const fn into_primitive(self) -> u32 {
94 self as u32
95 }
96}
97
98#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
100#[repr(u32)]
101pub enum PrepareFailureReason {
102 Internal = 0,
104 OutOfSpace = 1,
107 UnsupportedDowngrade = 2,
111}
112
113impl PrepareFailureReason {
114 #[inline]
115 pub fn from_primitive(prim: u32) -> Option<Self> {
116 match prim {
117 0 => Some(Self::Internal),
118 1 => Some(Self::OutOfSpace),
119 2 => Some(Self::UnsupportedDowngrade),
120 _ => None,
121 }
122 }
123
124 #[inline]
125 pub const fn into_primitive(self) -> u32 {
126 self as u32
127 }
128}
129
130#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
132#[repr(u32)]
133pub enum ResumeError {
134 NoUpdateInProgress = 1,
136 AttemptIdMismatch = 2,
138}
139
140impl ResumeError {
141 #[inline]
142 pub fn from_primitive(prim: u32) -> Option<Self> {
143 match prim {
144 1 => Some(Self::NoUpdateInProgress),
145 2 => Some(Self::AttemptIdMismatch),
146 _ => None,
147 }
148 }
149
150 #[inline]
151 pub const fn into_primitive(self) -> u32 {
152 self as u32
153 }
154}
155
156#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
158#[repr(u32)]
159pub enum StageFailureReason {
160 Internal = 0,
162 OutOfSpace = 1,
164}
165
166impl StageFailureReason {
167 #[inline]
168 pub fn from_primitive(prim: u32) -> Option<Self> {
169 match prim {
170 0 => Some(Self::Internal),
171 1 => Some(Self::OutOfSpace),
172 _ => None,
173 }
174 }
175
176 #[inline]
177 pub const fn into_primitive(self) -> u32 {
178 self as u32
179 }
180}
181
182#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
184#[repr(u32)]
185pub enum SuspendError {
186 NoUpdateInProgress = 1,
188 SuspendLimitExceeded = 2,
190 AttemptIdMismatch = 3,
192}
193
194impl SuspendError {
195 #[inline]
196 pub fn from_primitive(prim: u32) -> Option<Self> {
197 match prim {
198 1 => Some(Self::NoUpdateInProgress),
199 2 => Some(Self::SuspendLimitExceeded),
200 3 => Some(Self::AttemptIdMismatch),
201 _ => None,
202 }
203 }
204
205 #[inline]
206 pub const fn into_primitive(self) -> u32 {
207 self as u32
208 }
209}
210
211#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
213#[repr(u32)]
214pub enum UpdateNotStartedReason {
215 AlreadyInProgress = 1,
218}
219
220impl UpdateNotStartedReason {
221 #[inline]
222 pub fn from_primitive(prim: u32) -> Option<Self> {
223 match prim {
224 1 => Some(Self::AlreadyInProgress),
225 _ => None,
226 }
227 }
228
229 #[inline]
230 pub const fn into_primitive(self) -> u32 {
231 self as u32
232 }
233}
234
235#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
236pub struct InstallerCancelUpdateRequest {
237 pub attempt_id: Option<String>,
238}
239
240impl fidl::Persistable for InstallerCancelUpdateRequest {}
241
242#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
243pub struct InstallerMonitorUpdateResponse {
244 pub attached: bool,
245}
246
247impl fidl::Persistable for InstallerMonitorUpdateResponse {}
248
249#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
250pub struct InstallerResumeUpdateRequest {
251 pub attempt_id: Option<String>,
252}
253
254impl fidl::Persistable for InstallerResumeUpdateRequest {}
255
256#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
257pub struct InstallerSuspendUpdateRequest {
258 pub attempt_id: Option<String>,
259}
260
261impl fidl::Persistable for InstallerSuspendUpdateRequest {}
262
263#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
264pub struct InstallerStartUpdateResponse {
265 pub attempt_id: String,
266}
267
268impl fidl::Persistable for InstallerStartUpdateResponse {}
269
270#[derive(Clone, Debug, PartialEq)]
271pub struct MonitorOnStateRequest {
272 pub state: State,
273}
274
275impl fidl::Persistable for MonitorOnStateRequest {}
276
277#[derive(Clone, Debug, Default, PartialEq)]
279pub struct CanceledData {
280 #[doc(hidden)]
281 pub __source_breaking: fidl::marker::SourceBreaking,
282}
283
284impl fidl::Persistable for CanceledData {}
285
286#[derive(Clone, Debug, Default, PartialEq)]
288pub struct CommitData {
289 pub info: Option<UpdateInfo>,
290 pub progress: Option<InstallationProgress>,
291 #[doc(hidden)]
292 pub __source_breaking: fidl::marker::SourceBreaking,
293}
294
295impl fidl::Persistable for CommitData {}
296
297#[derive(Clone, Debug, Default, PartialEq)]
299pub struct CompleteData {
300 pub info: Option<UpdateInfo>,
301 pub progress: Option<InstallationProgress>,
302 #[doc(hidden)]
303 pub __source_breaking: fidl::marker::SourceBreaking,
304}
305
306impl fidl::Persistable for CompleteData {}
307
308#[derive(Clone, Debug, Default, PartialEq)]
310pub struct DeferRebootData {
311 pub info: Option<UpdateInfo>,
312 pub progress: Option<InstallationProgress>,
313 #[doc(hidden)]
314 pub __source_breaking: fidl::marker::SourceBreaking,
315}
316
317impl fidl::Persistable for DeferRebootData {}
318
319#[derive(Clone, Debug, Default, PartialEq)]
321pub struct FailCommitData {
322 pub info: Option<UpdateInfo>,
323 pub progress: Option<InstallationProgress>,
324 #[doc(hidden)]
325 pub __source_breaking: fidl::marker::SourceBreaking,
326}
327
328impl fidl::Persistable for FailCommitData {}
329
330#[derive(Clone, Debug, Default, PartialEq)]
332pub struct FailFetchData {
333 pub info: Option<UpdateInfo>,
334 pub progress: Option<InstallationProgress>,
335 pub reason: Option<FetchFailureReason>,
336 #[doc(hidden)]
337 pub __source_breaking: fidl::marker::SourceBreaking,
338}
339
340impl fidl::Persistable for FailFetchData {}
341
342#[derive(Clone, Debug, Default, PartialEq)]
344pub struct FailPrepareData {
345 pub reason: Option<PrepareFailureReason>,
346 #[doc(hidden)]
347 pub __source_breaking: fidl::marker::SourceBreaking,
348}
349
350impl fidl::Persistable for FailPrepareData {}
351
352#[derive(Clone, Debug, Default, PartialEq)]
354pub struct FailStageData {
355 pub info: Option<UpdateInfo>,
356 pub progress: Option<InstallationProgress>,
357 pub reason: Option<StageFailureReason>,
358 #[doc(hidden)]
359 pub __source_breaking: fidl::marker::SourceBreaking,
360}
361
362impl fidl::Persistable for FailStageData {}
363
364#[derive(Clone, Debug, Default, PartialEq)]
366pub struct FetchData {
367 pub info: Option<UpdateInfo>,
368 pub progress: Option<InstallationProgress>,
369 #[doc(hidden)]
370 pub __source_breaking: fidl::marker::SourceBreaking,
371}
372
373impl fidl::Persistable for FetchData {}
374
375#[derive(Clone, Debug, Default, PartialEq)]
377pub struct InstallationProgress {
378 pub fraction_completed: Option<f32>,
380 pub bytes_downloaded: Option<u64>,
384 #[doc(hidden)]
385 pub __source_breaking: fidl::marker::SourceBreaking,
386}
387
388impl fidl::Persistable for InstallationProgress {}
389
390#[derive(Clone, Debug, Default, PartialEq)]
392pub struct Options {
393 pub initiator: Option<Initiator>,
395 pub allow_attach_to_existing_attempt: Option<bool>,
402 pub should_write_recovery: Option<bool>,
405 #[doc(hidden)]
406 pub __source_breaking: fidl::marker::SourceBreaking,
407}
408
409impl fidl::Persistable for Options {}
410
411#[derive(Clone, Debug, Default, PartialEq)]
413pub struct PrepareData {
414 #[doc(hidden)]
415 pub __source_breaking: fidl::marker::SourceBreaking,
416}
417
418impl fidl::Persistable for PrepareData {}
419
420#[derive(Clone, Debug, Default, PartialEq)]
422pub struct RebootData {
423 pub info: Option<UpdateInfo>,
424 pub progress: Option<InstallationProgress>,
425 #[doc(hidden)]
426 pub __source_breaking: fidl::marker::SourceBreaking,
427}
428
429impl fidl::Persistable for RebootData {}
430
431#[derive(Clone, Debug, Default, PartialEq)]
433pub struct StageData {
434 pub info: Option<UpdateInfo>,
435 pub progress: Option<InstallationProgress>,
436 #[doc(hidden)]
437 pub __source_breaking: fidl::marker::SourceBreaking,
438}
439
440impl fidl::Persistable for StageData {}
441
442#[derive(Clone, Debug, Default, PartialEq)]
445pub struct UpdateInfo {
446 pub download_size: Option<u64>,
449 #[doc(hidden)]
450 pub __source_breaking: fidl::marker::SourceBreaking,
451}
452
453impl fidl::Persistable for UpdateInfo {}
454
455#[derive(Clone, Debug, Default, PartialEq)]
457pub struct WaitToRebootData {
458 pub info: Option<UpdateInfo>,
459 pub progress: Option<InstallationProgress>,
460 #[doc(hidden)]
461 pub __source_breaking: fidl::marker::SourceBreaking,
462}
463
464impl fidl::Persistable for WaitToRebootData {}
465
466#[derive(Clone, Debug, PartialEq)]
508pub enum State {
509 Prepare(PrepareData),
517 Stage(StageData),
524 Fetch(FetchData),
531 Commit(CommitData),
540 WaitToReboot(WaitToRebootData),
547 Reboot(RebootData),
551 DeferReboot(DeferRebootData),
556 Complete(CompleteData),
560 FailPrepare(FailPrepareData),
564 FailStage(FailStageData),
568 FailFetch(FailFetchData),
572 FailCommit(FailCommitData),
576 Canceled(CanceledData),
580}
581
582impl State {
583 #[inline]
584 pub fn ordinal(&self) -> u64 {
585 match *self {
586 Self::Prepare(_) => 1,
587 Self::Stage(_) => 2,
588 Self::Fetch(_) => 3,
589 Self::Commit(_) => 4,
590 Self::WaitToReboot(_) => 5,
591 Self::Reboot(_) => 6,
592 Self::DeferReboot(_) => 7,
593 Self::Complete(_) => 8,
594 Self::FailPrepare(_) => 9,
595 Self::FailStage(_) => 10,
596 Self::FailFetch(_) => 11,
597 Self::FailCommit(_) => 12,
598 Self::Canceled(_) => 13,
599 }
600 }
601}
602
603impl fidl::Persistable for State {}
604
605pub mod installer_ordinals {
606 pub const START_UPDATE: u64 = 0x2b1c5ba9167c320b;
607 pub const MONITOR_UPDATE: u64 = 0x21d54aa1fd825a32;
608 pub const SUSPEND_UPDATE: u64 = 0x788de328461f9950;
609 pub const RESUME_UPDATE: u64 = 0x7479e805fec33dd3;
610 pub const CANCEL_UPDATE: u64 = 0x472dec9160a1d0f;
611}
612
613pub mod monitor_ordinals {
614 pub const ON_STATE: u64 = 0x574105820d16cf26;
615}
616
617pub mod reboot_controller_ordinals {
618 pub const UNBLOCK: u64 = 0x5705625395e3d520;
619 pub const DETACH: u64 = 0x1daa560411955f16;
620}
621
622mod internal {
623 use super::*;
624 unsafe impl fidl::encoding::TypeMarker for CancelError {
625 type Owned = Self;
626
627 #[inline(always)]
628 fn inline_align(_context: fidl::encoding::Context) -> usize {
629 std::mem::align_of::<u32>()
630 }
631
632 #[inline(always)]
633 fn inline_size(_context: fidl::encoding::Context) -> usize {
634 std::mem::size_of::<u32>()
635 }
636
637 #[inline(always)]
638 fn encode_is_copy() -> bool {
639 true
640 }
641
642 #[inline(always)]
643 fn decode_is_copy() -> bool {
644 false
645 }
646 }
647
648 impl fidl::encoding::ValueTypeMarker for CancelError {
649 type Borrowed<'a> = Self;
650 #[inline(always)]
651 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
652 *value
653 }
654 }
655
656 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CancelError {
657 #[inline]
658 unsafe fn encode(
659 self,
660 encoder: &mut fidl::encoding::Encoder<'_, D>,
661 offset: usize,
662 _depth: fidl::encoding::Depth,
663 ) -> fidl::Result<()> {
664 encoder.debug_check_bounds::<Self>(offset);
665 encoder.write_num(self.into_primitive(), offset);
666 Ok(())
667 }
668 }
669
670 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CancelError {
671 #[inline(always)]
672 fn new_empty() -> Self {
673 Self::NoUpdateInProgress
674 }
675
676 #[inline]
677 unsafe fn decode(
678 &mut self,
679 decoder: &mut fidl::encoding::Decoder<'_, D>,
680 offset: usize,
681 _depth: fidl::encoding::Depth,
682 ) -> fidl::Result<()> {
683 decoder.debug_check_bounds::<Self>(offset);
684 let prim = decoder.read_num::<u32>(offset);
685
686 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
687 Ok(())
688 }
689 }
690 unsafe impl fidl::encoding::TypeMarker for FetchFailureReason {
691 type Owned = Self;
692
693 #[inline(always)]
694 fn inline_align(_context: fidl::encoding::Context) -> usize {
695 std::mem::align_of::<u32>()
696 }
697
698 #[inline(always)]
699 fn inline_size(_context: fidl::encoding::Context) -> usize {
700 std::mem::size_of::<u32>()
701 }
702
703 #[inline(always)]
704 fn encode_is_copy() -> bool {
705 true
706 }
707
708 #[inline(always)]
709 fn decode_is_copy() -> bool {
710 false
711 }
712 }
713
714 impl fidl::encoding::ValueTypeMarker for FetchFailureReason {
715 type Borrowed<'a> = Self;
716 #[inline(always)]
717 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
718 *value
719 }
720 }
721
722 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
723 for FetchFailureReason
724 {
725 #[inline]
726 unsafe fn encode(
727 self,
728 encoder: &mut fidl::encoding::Encoder<'_, D>,
729 offset: usize,
730 _depth: fidl::encoding::Depth,
731 ) -> fidl::Result<()> {
732 encoder.debug_check_bounds::<Self>(offset);
733 encoder.write_num(self.into_primitive(), offset);
734 Ok(())
735 }
736 }
737
738 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FetchFailureReason {
739 #[inline(always)]
740 fn new_empty() -> Self {
741 Self::Internal
742 }
743
744 #[inline]
745 unsafe fn decode(
746 &mut self,
747 decoder: &mut fidl::encoding::Decoder<'_, D>,
748 offset: usize,
749 _depth: fidl::encoding::Depth,
750 ) -> fidl::Result<()> {
751 decoder.debug_check_bounds::<Self>(offset);
752 let prim = decoder.read_num::<u32>(offset);
753
754 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
755 Ok(())
756 }
757 }
758 unsafe impl fidl::encoding::TypeMarker for Initiator {
759 type Owned = Self;
760
761 #[inline(always)]
762 fn inline_align(_context: fidl::encoding::Context) -> usize {
763 std::mem::align_of::<u32>()
764 }
765
766 #[inline(always)]
767 fn inline_size(_context: fidl::encoding::Context) -> usize {
768 std::mem::size_of::<u32>()
769 }
770
771 #[inline(always)]
772 fn encode_is_copy() -> bool {
773 true
774 }
775
776 #[inline(always)]
777 fn decode_is_copy() -> bool {
778 false
779 }
780 }
781
782 impl fidl::encoding::ValueTypeMarker for Initiator {
783 type Borrowed<'a> = Self;
784 #[inline(always)]
785 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
786 *value
787 }
788 }
789
790 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Initiator {
791 #[inline]
792 unsafe fn encode(
793 self,
794 encoder: &mut fidl::encoding::Encoder<'_, D>,
795 offset: usize,
796 _depth: fidl::encoding::Depth,
797 ) -> fidl::Result<()> {
798 encoder.debug_check_bounds::<Self>(offset);
799 encoder.write_num(self.into_primitive(), offset);
800 Ok(())
801 }
802 }
803
804 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Initiator {
805 #[inline(always)]
806 fn new_empty() -> Self {
807 Self::User
808 }
809
810 #[inline]
811 unsafe fn decode(
812 &mut self,
813 decoder: &mut fidl::encoding::Decoder<'_, D>,
814 offset: usize,
815 _depth: fidl::encoding::Depth,
816 ) -> fidl::Result<()> {
817 decoder.debug_check_bounds::<Self>(offset);
818 let prim = decoder.read_num::<u32>(offset);
819
820 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
821 Ok(())
822 }
823 }
824 unsafe impl fidl::encoding::TypeMarker for PrepareFailureReason {
825 type Owned = Self;
826
827 #[inline(always)]
828 fn inline_align(_context: fidl::encoding::Context) -> usize {
829 std::mem::align_of::<u32>()
830 }
831
832 #[inline(always)]
833 fn inline_size(_context: fidl::encoding::Context) -> usize {
834 std::mem::size_of::<u32>()
835 }
836
837 #[inline(always)]
838 fn encode_is_copy() -> bool {
839 true
840 }
841
842 #[inline(always)]
843 fn decode_is_copy() -> bool {
844 false
845 }
846 }
847
848 impl fidl::encoding::ValueTypeMarker for PrepareFailureReason {
849 type Borrowed<'a> = Self;
850 #[inline(always)]
851 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
852 *value
853 }
854 }
855
856 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
857 for PrepareFailureReason
858 {
859 #[inline]
860 unsafe fn encode(
861 self,
862 encoder: &mut fidl::encoding::Encoder<'_, D>,
863 offset: usize,
864 _depth: fidl::encoding::Depth,
865 ) -> fidl::Result<()> {
866 encoder.debug_check_bounds::<Self>(offset);
867 encoder.write_num(self.into_primitive(), offset);
868 Ok(())
869 }
870 }
871
872 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PrepareFailureReason {
873 #[inline(always)]
874 fn new_empty() -> Self {
875 Self::Internal
876 }
877
878 #[inline]
879 unsafe fn decode(
880 &mut self,
881 decoder: &mut fidl::encoding::Decoder<'_, D>,
882 offset: usize,
883 _depth: fidl::encoding::Depth,
884 ) -> fidl::Result<()> {
885 decoder.debug_check_bounds::<Self>(offset);
886 let prim = decoder.read_num::<u32>(offset);
887
888 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
889 Ok(())
890 }
891 }
892 unsafe impl fidl::encoding::TypeMarker for ResumeError {
893 type Owned = Self;
894
895 #[inline(always)]
896 fn inline_align(_context: fidl::encoding::Context) -> usize {
897 std::mem::align_of::<u32>()
898 }
899
900 #[inline(always)]
901 fn inline_size(_context: fidl::encoding::Context) -> usize {
902 std::mem::size_of::<u32>()
903 }
904
905 #[inline(always)]
906 fn encode_is_copy() -> bool {
907 true
908 }
909
910 #[inline(always)]
911 fn decode_is_copy() -> bool {
912 false
913 }
914 }
915
916 impl fidl::encoding::ValueTypeMarker for ResumeError {
917 type Borrowed<'a> = Self;
918 #[inline(always)]
919 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
920 *value
921 }
922 }
923
924 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResumeError {
925 #[inline]
926 unsafe fn encode(
927 self,
928 encoder: &mut fidl::encoding::Encoder<'_, D>,
929 offset: usize,
930 _depth: fidl::encoding::Depth,
931 ) -> fidl::Result<()> {
932 encoder.debug_check_bounds::<Self>(offset);
933 encoder.write_num(self.into_primitive(), offset);
934 Ok(())
935 }
936 }
937
938 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResumeError {
939 #[inline(always)]
940 fn new_empty() -> Self {
941 Self::NoUpdateInProgress
942 }
943
944 #[inline]
945 unsafe fn decode(
946 &mut self,
947 decoder: &mut fidl::encoding::Decoder<'_, D>,
948 offset: usize,
949 _depth: fidl::encoding::Depth,
950 ) -> fidl::Result<()> {
951 decoder.debug_check_bounds::<Self>(offset);
952 let prim = decoder.read_num::<u32>(offset);
953
954 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
955 Ok(())
956 }
957 }
958 unsafe impl fidl::encoding::TypeMarker for StageFailureReason {
959 type Owned = Self;
960
961 #[inline(always)]
962 fn inline_align(_context: fidl::encoding::Context) -> usize {
963 std::mem::align_of::<u32>()
964 }
965
966 #[inline(always)]
967 fn inline_size(_context: fidl::encoding::Context) -> usize {
968 std::mem::size_of::<u32>()
969 }
970
971 #[inline(always)]
972 fn encode_is_copy() -> bool {
973 true
974 }
975
976 #[inline(always)]
977 fn decode_is_copy() -> bool {
978 false
979 }
980 }
981
982 impl fidl::encoding::ValueTypeMarker for StageFailureReason {
983 type Borrowed<'a> = Self;
984 #[inline(always)]
985 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
986 *value
987 }
988 }
989
990 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
991 for StageFailureReason
992 {
993 #[inline]
994 unsafe fn encode(
995 self,
996 encoder: &mut fidl::encoding::Encoder<'_, D>,
997 offset: usize,
998 _depth: fidl::encoding::Depth,
999 ) -> fidl::Result<()> {
1000 encoder.debug_check_bounds::<Self>(offset);
1001 encoder.write_num(self.into_primitive(), offset);
1002 Ok(())
1003 }
1004 }
1005
1006 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StageFailureReason {
1007 #[inline(always)]
1008 fn new_empty() -> Self {
1009 Self::Internal
1010 }
1011
1012 #[inline]
1013 unsafe fn decode(
1014 &mut self,
1015 decoder: &mut fidl::encoding::Decoder<'_, D>,
1016 offset: usize,
1017 _depth: fidl::encoding::Depth,
1018 ) -> fidl::Result<()> {
1019 decoder.debug_check_bounds::<Self>(offset);
1020 let prim = decoder.read_num::<u32>(offset);
1021
1022 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1023 Ok(())
1024 }
1025 }
1026 unsafe impl fidl::encoding::TypeMarker for SuspendError {
1027 type Owned = Self;
1028
1029 #[inline(always)]
1030 fn inline_align(_context: fidl::encoding::Context) -> usize {
1031 std::mem::align_of::<u32>()
1032 }
1033
1034 #[inline(always)]
1035 fn inline_size(_context: fidl::encoding::Context) -> usize {
1036 std::mem::size_of::<u32>()
1037 }
1038
1039 #[inline(always)]
1040 fn encode_is_copy() -> bool {
1041 true
1042 }
1043
1044 #[inline(always)]
1045 fn decode_is_copy() -> bool {
1046 false
1047 }
1048 }
1049
1050 impl fidl::encoding::ValueTypeMarker for SuspendError {
1051 type Borrowed<'a> = Self;
1052 #[inline(always)]
1053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1054 *value
1055 }
1056 }
1057
1058 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SuspendError {
1059 #[inline]
1060 unsafe fn encode(
1061 self,
1062 encoder: &mut fidl::encoding::Encoder<'_, D>,
1063 offset: usize,
1064 _depth: fidl::encoding::Depth,
1065 ) -> fidl::Result<()> {
1066 encoder.debug_check_bounds::<Self>(offset);
1067 encoder.write_num(self.into_primitive(), offset);
1068 Ok(())
1069 }
1070 }
1071
1072 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendError {
1073 #[inline(always)]
1074 fn new_empty() -> Self {
1075 Self::NoUpdateInProgress
1076 }
1077
1078 #[inline]
1079 unsafe fn decode(
1080 &mut self,
1081 decoder: &mut fidl::encoding::Decoder<'_, D>,
1082 offset: usize,
1083 _depth: fidl::encoding::Depth,
1084 ) -> fidl::Result<()> {
1085 decoder.debug_check_bounds::<Self>(offset);
1086 let prim = decoder.read_num::<u32>(offset);
1087
1088 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1089 Ok(())
1090 }
1091 }
1092 unsafe impl fidl::encoding::TypeMarker for UpdateNotStartedReason {
1093 type Owned = Self;
1094
1095 #[inline(always)]
1096 fn inline_align(_context: fidl::encoding::Context) -> usize {
1097 std::mem::align_of::<u32>()
1098 }
1099
1100 #[inline(always)]
1101 fn inline_size(_context: fidl::encoding::Context) -> usize {
1102 std::mem::size_of::<u32>()
1103 }
1104
1105 #[inline(always)]
1106 fn encode_is_copy() -> bool {
1107 true
1108 }
1109
1110 #[inline(always)]
1111 fn decode_is_copy() -> bool {
1112 false
1113 }
1114 }
1115
1116 impl fidl::encoding::ValueTypeMarker for UpdateNotStartedReason {
1117 type Borrowed<'a> = Self;
1118 #[inline(always)]
1119 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1120 *value
1121 }
1122 }
1123
1124 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1125 for UpdateNotStartedReason
1126 {
1127 #[inline]
1128 unsafe fn encode(
1129 self,
1130 encoder: &mut fidl::encoding::Encoder<'_, D>,
1131 offset: usize,
1132 _depth: fidl::encoding::Depth,
1133 ) -> fidl::Result<()> {
1134 encoder.debug_check_bounds::<Self>(offset);
1135 encoder.write_num(self.into_primitive(), offset);
1136 Ok(())
1137 }
1138 }
1139
1140 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1141 for UpdateNotStartedReason
1142 {
1143 #[inline(always)]
1144 fn new_empty() -> Self {
1145 Self::AlreadyInProgress
1146 }
1147
1148 #[inline]
1149 unsafe fn decode(
1150 &mut self,
1151 decoder: &mut fidl::encoding::Decoder<'_, D>,
1152 offset: usize,
1153 _depth: fidl::encoding::Depth,
1154 ) -> fidl::Result<()> {
1155 decoder.debug_check_bounds::<Self>(offset);
1156 let prim = decoder.read_num::<u32>(offset);
1157
1158 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1159 Ok(())
1160 }
1161 }
1162
1163 impl fidl::encoding::ValueTypeMarker for InstallerCancelUpdateRequest {
1164 type Borrowed<'a> = &'a Self;
1165 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1166 value
1167 }
1168 }
1169
1170 unsafe impl fidl::encoding::TypeMarker for InstallerCancelUpdateRequest {
1171 type Owned = Self;
1172
1173 #[inline(always)]
1174 fn inline_align(_context: fidl::encoding::Context) -> usize {
1175 8
1176 }
1177
1178 #[inline(always)]
1179 fn inline_size(_context: fidl::encoding::Context) -> usize {
1180 16
1181 }
1182 }
1183
1184 unsafe impl<D: fidl::encoding::ResourceDialect>
1185 fidl::encoding::Encode<InstallerCancelUpdateRequest, D> for &InstallerCancelUpdateRequest
1186 {
1187 #[inline]
1188 unsafe fn encode(
1189 self,
1190 encoder: &mut fidl::encoding::Encoder<'_, D>,
1191 offset: usize,
1192 _depth: fidl::encoding::Depth,
1193 ) -> fidl::Result<()> {
1194 encoder.debug_check_bounds::<InstallerCancelUpdateRequest>(offset);
1195 fidl::encoding::Encode::<InstallerCancelUpdateRequest, D>::encode(
1197 (
1198 <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1199 ),
1200 encoder, offset, _depth
1201 )
1202 }
1203 }
1204 unsafe impl<
1205 D: fidl::encoding::ResourceDialect,
1206 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1207 > fidl::encoding::Encode<InstallerCancelUpdateRequest, D> for (T0,)
1208 {
1209 #[inline]
1210 unsafe fn encode(
1211 self,
1212 encoder: &mut fidl::encoding::Encoder<'_, D>,
1213 offset: usize,
1214 depth: fidl::encoding::Depth,
1215 ) -> fidl::Result<()> {
1216 encoder.debug_check_bounds::<InstallerCancelUpdateRequest>(offset);
1217 self.0.encode(encoder, offset + 0, depth)?;
1221 Ok(())
1222 }
1223 }
1224
1225 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1226 for InstallerCancelUpdateRequest
1227 {
1228 #[inline(always)]
1229 fn new_empty() -> Self {
1230 Self {
1231 attempt_id: fidl::new_empty!(
1232 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1233 D
1234 ),
1235 }
1236 }
1237
1238 #[inline]
1239 unsafe fn decode(
1240 &mut self,
1241 decoder: &mut fidl::encoding::Decoder<'_, D>,
1242 offset: usize,
1243 _depth: fidl::encoding::Depth,
1244 ) -> fidl::Result<()> {
1245 decoder.debug_check_bounds::<Self>(offset);
1246 fidl::decode!(
1248 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1249 D,
1250 &mut self.attempt_id,
1251 decoder,
1252 offset + 0,
1253 _depth
1254 )?;
1255 Ok(())
1256 }
1257 }
1258
1259 impl fidl::encoding::ValueTypeMarker for InstallerMonitorUpdateResponse {
1260 type Borrowed<'a> = &'a Self;
1261 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1262 value
1263 }
1264 }
1265
1266 unsafe impl fidl::encoding::TypeMarker for InstallerMonitorUpdateResponse {
1267 type Owned = Self;
1268
1269 #[inline(always)]
1270 fn inline_align(_context: fidl::encoding::Context) -> usize {
1271 1
1272 }
1273
1274 #[inline(always)]
1275 fn inline_size(_context: fidl::encoding::Context) -> usize {
1276 1
1277 }
1278 }
1279
1280 unsafe impl<D: fidl::encoding::ResourceDialect>
1281 fidl::encoding::Encode<InstallerMonitorUpdateResponse, D>
1282 for &InstallerMonitorUpdateResponse
1283 {
1284 #[inline]
1285 unsafe fn encode(
1286 self,
1287 encoder: &mut fidl::encoding::Encoder<'_, D>,
1288 offset: usize,
1289 _depth: fidl::encoding::Depth,
1290 ) -> fidl::Result<()> {
1291 encoder.debug_check_bounds::<InstallerMonitorUpdateResponse>(offset);
1292 fidl::encoding::Encode::<InstallerMonitorUpdateResponse, D>::encode(
1294 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.attached),),
1295 encoder,
1296 offset,
1297 _depth,
1298 )
1299 }
1300 }
1301 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1302 fidl::encoding::Encode<InstallerMonitorUpdateResponse, D> for (T0,)
1303 {
1304 #[inline]
1305 unsafe fn encode(
1306 self,
1307 encoder: &mut fidl::encoding::Encoder<'_, D>,
1308 offset: usize,
1309 depth: fidl::encoding::Depth,
1310 ) -> fidl::Result<()> {
1311 encoder.debug_check_bounds::<InstallerMonitorUpdateResponse>(offset);
1312 self.0.encode(encoder, offset + 0, depth)?;
1316 Ok(())
1317 }
1318 }
1319
1320 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1321 for InstallerMonitorUpdateResponse
1322 {
1323 #[inline(always)]
1324 fn new_empty() -> Self {
1325 Self { attached: fidl::new_empty!(bool, D) }
1326 }
1327
1328 #[inline]
1329 unsafe fn decode(
1330 &mut self,
1331 decoder: &mut fidl::encoding::Decoder<'_, D>,
1332 offset: usize,
1333 _depth: fidl::encoding::Depth,
1334 ) -> fidl::Result<()> {
1335 decoder.debug_check_bounds::<Self>(offset);
1336 fidl::decode!(bool, D, &mut self.attached, decoder, offset + 0, _depth)?;
1338 Ok(())
1339 }
1340 }
1341
1342 impl fidl::encoding::ValueTypeMarker for InstallerResumeUpdateRequest {
1343 type Borrowed<'a> = &'a Self;
1344 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1345 value
1346 }
1347 }
1348
1349 unsafe impl fidl::encoding::TypeMarker for InstallerResumeUpdateRequest {
1350 type Owned = Self;
1351
1352 #[inline(always)]
1353 fn inline_align(_context: fidl::encoding::Context) -> usize {
1354 8
1355 }
1356
1357 #[inline(always)]
1358 fn inline_size(_context: fidl::encoding::Context) -> usize {
1359 16
1360 }
1361 }
1362
1363 unsafe impl<D: fidl::encoding::ResourceDialect>
1364 fidl::encoding::Encode<InstallerResumeUpdateRequest, D> for &InstallerResumeUpdateRequest
1365 {
1366 #[inline]
1367 unsafe fn encode(
1368 self,
1369 encoder: &mut fidl::encoding::Encoder<'_, D>,
1370 offset: usize,
1371 _depth: fidl::encoding::Depth,
1372 ) -> fidl::Result<()> {
1373 encoder.debug_check_bounds::<InstallerResumeUpdateRequest>(offset);
1374 fidl::encoding::Encode::<InstallerResumeUpdateRequest, D>::encode(
1376 (
1377 <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1378 ),
1379 encoder, offset, _depth
1380 )
1381 }
1382 }
1383 unsafe impl<
1384 D: fidl::encoding::ResourceDialect,
1385 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1386 > fidl::encoding::Encode<InstallerResumeUpdateRequest, D> for (T0,)
1387 {
1388 #[inline]
1389 unsafe fn encode(
1390 self,
1391 encoder: &mut fidl::encoding::Encoder<'_, D>,
1392 offset: usize,
1393 depth: fidl::encoding::Depth,
1394 ) -> fidl::Result<()> {
1395 encoder.debug_check_bounds::<InstallerResumeUpdateRequest>(offset);
1396 self.0.encode(encoder, offset + 0, depth)?;
1400 Ok(())
1401 }
1402 }
1403
1404 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1405 for InstallerResumeUpdateRequest
1406 {
1407 #[inline(always)]
1408 fn new_empty() -> Self {
1409 Self {
1410 attempt_id: fidl::new_empty!(
1411 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1412 D
1413 ),
1414 }
1415 }
1416
1417 #[inline]
1418 unsafe fn decode(
1419 &mut self,
1420 decoder: &mut fidl::encoding::Decoder<'_, D>,
1421 offset: usize,
1422 _depth: fidl::encoding::Depth,
1423 ) -> fidl::Result<()> {
1424 decoder.debug_check_bounds::<Self>(offset);
1425 fidl::decode!(
1427 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1428 D,
1429 &mut self.attempt_id,
1430 decoder,
1431 offset + 0,
1432 _depth
1433 )?;
1434 Ok(())
1435 }
1436 }
1437
1438 impl fidl::encoding::ValueTypeMarker for InstallerSuspendUpdateRequest {
1439 type Borrowed<'a> = &'a Self;
1440 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1441 value
1442 }
1443 }
1444
1445 unsafe impl fidl::encoding::TypeMarker for InstallerSuspendUpdateRequest {
1446 type Owned = Self;
1447
1448 #[inline(always)]
1449 fn inline_align(_context: fidl::encoding::Context) -> usize {
1450 8
1451 }
1452
1453 #[inline(always)]
1454 fn inline_size(_context: fidl::encoding::Context) -> usize {
1455 16
1456 }
1457 }
1458
1459 unsafe impl<D: fidl::encoding::ResourceDialect>
1460 fidl::encoding::Encode<InstallerSuspendUpdateRequest, D>
1461 for &InstallerSuspendUpdateRequest
1462 {
1463 #[inline]
1464 unsafe fn encode(
1465 self,
1466 encoder: &mut fidl::encoding::Encoder<'_, D>,
1467 offset: usize,
1468 _depth: fidl::encoding::Depth,
1469 ) -> fidl::Result<()> {
1470 encoder.debug_check_bounds::<InstallerSuspendUpdateRequest>(offset);
1471 fidl::encoding::Encode::<InstallerSuspendUpdateRequest, D>::encode(
1473 (
1474 <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1475 ),
1476 encoder, offset, _depth
1477 )
1478 }
1479 }
1480 unsafe impl<
1481 D: fidl::encoding::ResourceDialect,
1482 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1483 > fidl::encoding::Encode<InstallerSuspendUpdateRequest, D> for (T0,)
1484 {
1485 #[inline]
1486 unsafe fn encode(
1487 self,
1488 encoder: &mut fidl::encoding::Encoder<'_, D>,
1489 offset: usize,
1490 depth: fidl::encoding::Depth,
1491 ) -> fidl::Result<()> {
1492 encoder.debug_check_bounds::<InstallerSuspendUpdateRequest>(offset);
1493 self.0.encode(encoder, offset + 0, depth)?;
1497 Ok(())
1498 }
1499 }
1500
1501 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1502 for InstallerSuspendUpdateRequest
1503 {
1504 #[inline(always)]
1505 fn new_empty() -> Self {
1506 Self {
1507 attempt_id: fidl::new_empty!(
1508 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1509 D
1510 ),
1511 }
1512 }
1513
1514 #[inline]
1515 unsafe fn decode(
1516 &mut self,
1517 decoder: &mut fidl::encoding::Decoder<'_, D>,
1518 offset: usize,
1519 _depth: fidl::encoding::Depth,
1520 ) -> fidl::Result<()> {
1521 decoder.debug_check_bounds::<Self>(offset);
1522 fidl::decode!(
1524 fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1525 D,
1526 &mut self.attempt_id,
1527 decoder,
1528 offset + 0,
1529 _depth
1530 )?;
1531 Ok(())
1532 }
1533 }
1534
1535 impl fidl::encoding::ValueTypeMarker for InstallerStartUpdateResponse {
1536 type Borrowed<'a> = &'a Self;
1537 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1538 value
1539 }
1540 }
1541
1542 unsafe impl fidl::encoding::TypeMarker for InstallerStartUpdateResponse {
1543 type Owned = Self;
1544
1545 #[inline(always)]
1546 fn inline_align(_context: fidl::encoding::Context) -> usize {
1547 8
1548 }
1549
1550 #[inline(always)]
1551 fn inline_size(_context: fidl::encoding::Context) -> usize {
1552 16
1553 }
1554 }
1555
1556 unsafe impl<D: fidl::encoding::ResourceDialect>
1557 fidl::encoding::Encode<InstallerStartUpdateResponse, D> for &InstallerStartUpdateResponse
1558 {
1559 #[inline]
1560 unsafe fn encode(
1561 self,
1562 encoder: &mut fidl::encoding::Encoder<'_, D>,
1563 offset: usize,
1564 _depth: fidl::encoding::Depth,
1565 ) -> fidl::Result<()> {
1566 encoder.debug_check_bounds::<InstallerStartUpdateResponse>(offset);
1567 fidl::encoding::Encode::<InstallerStartUpdateResponse, D>::encode(
1569 (<fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(
1570 &self.attempt_id,
1571 ),),
1572 encoder,
1573 offset,
1574 _depth,
1575 )
1576 }
1577 }
1578 unsafe impl<
1579 D: fidl::encoding::ResourceDialect,
1580 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
1581 > fidl::encoding::Encode<InstallerStartUpdateResponse, D> for (T0,)
1582 {
1583 #[inline]
1584 unsafe fn encode(
1585 self,
1586 encoder: &mut fidl::encoding::Encoder<'_, D>,
1587 offset: usize,
1588 depth: fidl::encoding::Depth,
1589 ) -> fidl::Result<()> {
1590 encoder.debug_check_bounds::<InstallerStartUpdateResponse>(offset);
1591 self.0.encode(encoder, offset + 0, depth)?;
1595 Ok(())
1596 }
1597 }
1598
1599 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1600 for InstallerStartUpdateResponse
1601 {
1602 #[inline(always)]
1603 fn new_empty() -> Self {
1604 Self { attempt_id: fidl::new_empty!(fidl::encoding::BoundedString<36>, D) }
1605 }
1606
1607 #[inline]
1608 unsafe fn decode(
1609 &mut self,
1610 decoder: &mut fidl::encoding::Decoder<'_, D>,
1611 offset: usize,
1612 _depth: fidl::encoding::Depth,
1613 ) -> fidl::Result<()> {
1614 decoder.debug_check_bounds::<Self>(offset);
1615 fidl::decode!(
1617 fidl::encoding::BoundedString<36>,
1618 D,
1619 &mut self.attempt_id,
1620 decoder,
1621 offset + 0,
1622 _depth
1623 )?;
1624 Ok(())
1625 }
1626 }
1627
1628 impl fidl::encoding::ValueTypeMarker for MonitorOnStateRequest {
1629 type Borrowed<'a> = &'a Self;
1630 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1631 value
1632 }
1633 }
1634
1635 unsafe impl fidl::encoding::TypeMarker for MonitorOnStateRequest {
1636 type Owned = Self;
1637
1638 #[inline(always)]
1639 fn inline_align(_context: fidl::encoding::Context) -> usize {
1640 8
1641 }
1642
1643 #[inline(always)]
1644 fn inline_size(_context: fidl::encoding::Context) -> usize {
1645 16
1646 }
1647 }
1648
1649 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MonitorOnStateRequest, D>
1650 for &MonitorOnStateRequest
1651 {
1652 #[inline]
1653 unsafe fn encode(
1654 self,
1655 encoder: &mut fidl::encoding::Encoder<'_, D>,
1656 offset: usize,
1657 _depth: fidl::encoding::Depth,
1658 ) -> fidl::Result<()> {
1659 encoder.debug_check_bounds::<MonitorOnStateRequest>(offset);
1660 fidl::encoding::Encode::<MonitorOnStateRequest, D>::encode(
1662 (<State as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
1663 encoder,
1664 offset,
1665 _depth,
1666 )
1667 }
1668 }
1669 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<State, D>>
1670 fidl::encoding::Encode<MonitorOnStateRequest, D> for (T0,)
1671 {
1672 #[inline]
1673 unsafe fn encode(
1674 self,
1675 encoder: &mut fidl::encoding::Encoder<'_, D>,
1676 offset: usize,
1677 depth: fidl::encoding::Depth,
1678 ) -> fidl::Result<()> {
1679 encoder.debug_check_bounds::<MonitorOnStateRequest>(offset);
1680 self.0.encode(encoder, offset + 0, depth)?;
1684 Ok(())
1685 }
1686 }
1687
1688 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MonitorOnStateRequest {
1689 #[inline(always)]
1690 fn new_empty() -> Self {
1691 Self { state: fidl::new_empty!(State, D) }
1692 }
1693
1694 #[inline]
1695 unsafe fn decode(
1696 &mut self,
1697 decoder: &mut fidl::encoding::Decoder<'_, D>,
1698 offset: usize,
1699 _depth: fidl::encoding::Depth,
1700 ) -> fidl::Result<()> {
1701 decoder.debug_check_bounds::<Self>(offset);
1702 fidl::decode!(State, D, &mut self.state, decoder, offset + 0, _depth)?;
1704 Ok(())
1705 }
1706 }
1707
1708 impl CanceledData {
1709 #[inline(always)]
1710 fn max_ordinal_present(&self) -> u64 {
1711 0
1712 }
1713 }
1714
1715 impl fidl::encoding::ValueTypeMarker for CanceledData {
1716 type Borrowed<'a> = &'a Self;
1717 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1718 value
1719 }
1720 }
1721
1722 unsafe impl fidl::encoding::TypeMarker for CanceledData {
1723 type Owned = Self;
1724
1725 #[inline(always)]
1726 fn inline_align(_context: fidl::encoding::Context) -> usize {
1727 8
1728 }
1729
1730 #[inline(always)]
1731 fn inline_size(_context: fidl::encoding::Context) -> usize {
1732 16
1733 }
1734 }
1735
1736 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CanceledData, D>
1737 for &CanceledData
1738 {
1739 unsafe fn encode(
1740 self,
1741 encoder: &mut fidl::encoding::Encoder<'_, D>,
1742 offset: usize,
1743 mut depth: fidl::encoding::Depth,
1744 ) -> fidl::Result<()> {
1745 encoder.debug_check_bounds::<CanceledData>(offset);
1746 let max_ordinal: u64 = self.max_ordinal_present();
1748 encoder.write_num(max_ordinal, offset);
1749 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1750 if max_ordinal == 0 {
1752 return Ok(());
1753 }
1754 depth.increment()?;
1755 let envelope_size = 8;
1756 let bytes_len = max_ordinal as usize * envelope_size;
1757 #[allow(unused_variables)]
1758 let offset = encoder.out_of_line_offset(bytes_len);
1759 let mut _prev_end_offset: usize = 0;
1760
1761 Ok(())
1762 }
1763 }
1764
1765 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CanceledData {
1766 #[inline(always)]
1767 fn new_empty() -> Self {
1768 Self::default()
1769 }
1770
1771 unsafe fn decode(
1772 &mut self,
1773 decoder: &mut fidl::encoding::Decoder<'_, D>,
1774 offset: usize,
1775 mut depth: fidl::encoding::Depth,
1776 ) -> fidl::Result<()> {
1777 decoder.debug_check_bounds::<Self>(offset);
1778 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1779 None => return Err(fidl::Error::NotNullable),
1780 Some(len) => len,
1781 };
1782 if len == 0 {
1784 return Ok(());
1785 };
1786 depth.increment()?;
1787 let envelope_size = 8;
1788 let bytes_len = len * envelope_size;
1789 let offset = decoder.out_of_line_offset(bytes_len)?;
1790 let mut _next_ordinal_to_read = 0;
1792 let mut next_offset = offset;
1793 let end_offset = offset + bytes_len;
1794
1795 while next_offset < end_offset {
1797 _next_ordinal_to_read += 1;
1798 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1799 next_offset += envelope_size;
1800 }
1801
1802 Ok(())
1803 }
1804 }
1805
1806 impl CommitData {
1807 #[inline(always)]
1808 fn max_ordinal_present(&self) -> u64 {
1809 if let Some(_) = self.progress {
1810 return 2;
1811 }
1812 if let Some(_) = self.info {
1813 return 1;
1814 }
1815 0
1816 }
1817 }
1818
1819 impl fidl::encoding::ValueTypeMarker for CommitData {
1820 type Borrowed<'a> = &'a Self;
1821 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1822 value
1823 }
1824 }
1825
1826 unsafe impl fidl::encoding::TypeMarker for CommitData {
1827 type Owned = Self;
1828
1829 #[inline(always)]
1830 fn inline_align(_context: fidl::encoding::Context) -> usize {
1831 8
1832 }
1833
1834 #[inline(always)]
1835 fn inline_size(_context: fidl::encoding::Context) -> usize {
1836 16
1837 }
1838 }
1839
1840 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CommitData, D>
1841 for &CommitData
1842 {
1843 unsafe fn encode(
1844 self,
1845 encoder: &mut fidl::encoding::Encoder<'_, D>,
1846 offset: usize,
1847 mut depth: fidl::encoding::Depth,
1848 ) -> fidl::Result<()> {
1849 encoder.debug_check_bounds::<CommitData>(offset);
1850 let max_ordinal: u64 = self.max_ordinal_present();
1852 encoder.write_num(max_ordinal, offset);
1853 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1854 if max_ordinal == 0 {
1856 return Ok(());
1857 }
1858 depth.increment()?;
1859 let envelope_size = 8;
1860 let bytes_len = max_ordinal as usize * envelope_size;
1861 #[allow(unused_variables)]
1862 let offset = encoder.out_of_line_offset(bytes_len);
1863 let mut _prev_end_offset: usize = 0;
1864 if 1 > max_ordinal {
1865 return Ok(());
1866 }
1867
1868 let cur_offset: usize = (1 - 1) * envelope_size;
1871
1872 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1874
1875 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
1880 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
1881 encoder,
1882 offset + cur_offset,
1883 depth,
1884 )?;
1885
1886 _prev_end_offset = cur_offset + envelope_size;
1887 if 2 > max_ordinal {
1888 return Ok(());
1889 }
1890
1891 let cur_offset: usize = (2 - 1) * envelope_size;
1894
1895 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1897
1898 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
1903 self.progress
1904 .as_ref()
1905 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
1906 encoder,
1907 offset + cur_offset,
1908 depth,
1909 )?;
1910
1911 _prev_end_offset = cur_offset + envelope_size;
1912
1913 Ok(())
1914 }
1915 }
1916
1917 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CommitData {
1918 #[inline(always)]
1919 fn new_empty() -> Self {
1920 Self::default()
1921 }
1922
1923 unsafe fn decode(
1924 &mut self,
1925 decoder: &mut fidl::encoding::Decoder<'_, D>,
1926 offset: usize,
1927 mut depth: fidl::encoding::Depth,
1928 ) -> fidl::Result<()> {
1929 decoder.debug_check_bounds::<Self>(offset);
1930 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1931 None => return Err(fidl::Error::NotNullable),
1932 Some(len) => len,
1933 };
1934 if len == 0 {
1936 return Ok(());
1937 };
1938 depth.increment()?;
1939 let envelope_size = 8;
1940 let bytes_len = len * envelope_size;
1941 let offset = decoder.out_of_line_offset(bytes_len)?;
1942 let mut _next_ordinal_to_read = 0;
1944 let mut next_offset = offset;
1945 let end_offset = offset + bytes_len;
1946 _next_ordinal_to_read += 1;
1947 if next_offset >= end_offset {
1948 return Ok(());
1949 }
1950
1951 while _next_ordinal_to_read < 1 {
1953 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1954 _next_ordinal_to_read += 1;
1955 next_offset += envelope_size;
1956 }
1957
1958 let next_out_of_line = decoder.next_out_of_line();
1959 let handles_before = decoder.remaining_handles();
1960 if let Some((inlined, num_bytes, num_handles)) =
1961 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1962 {
1963 let member_inline_size =
1964 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1965 if inlined != (member_inline_size <= 4) {
1966 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1967 }
1968 let inner_offset;
1969 let mut inner_depth = depth.clone();
1970 if inlined {
1971 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1972 inner_offset = next_offset;
1973 } else {
1974 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1975 inner_depth.increment()?;
1976 }
1977 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
1978 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
1979 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1980 {
1981 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1982 }
1983 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1984 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1985 }
1986 }
1987
1988 next_offset += envelope_size;
1989 _next_ordinal_to_read += 1;
1990 if next_offset >= end_offset {
1991 return Ok(());
1992 }
1993
1994 while _next_ordinal_to_read < 2 {
1996 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1997 _next_ordinal_to_read += 1;
1998 next_offset += envelope_size;
1999 }
2000
2001 let next_out_of_line = decoder.next_out_of_line();
2002 let handles_before = decoder.remaining_handles();
2003 if let Some((inlined, num_bytes, num_handles)) =
2004 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2005 {
2006 let member_inline_size =
2007 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2008 decoder.context,
2009 );
2010 if inlined != (member_inline_size <= 4) {
2011 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2012 }
2013 let inner_offset;
2014 let mut inner_depth = depth.clone();
2015 if inlined {
2016 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2017 inner_offset = next_offset;
2018 } else {
2019 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2020 inner_depth.increment()?;
2021 }
2022 let val_ref =
2023 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2024 fidl::decode!(
2025 InstallationProgress,
2026 D,
2027 val_ref,
2028 decoder,
2029 inner_offset,
2030 inner_depth
2031 )?;
2032 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2033 {
2034 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2035 }
2036 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2037 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2038 }
2039 }
2040
2041 next_offset += envelope_size;
2042
2043 while next_offset < end_offset {
2045 _next_ordinal_to_read += 1;
2046 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2047 next_offset += envelope_size;
2048 }
2049
2050 Ok(())
2051 }
2052 }
2053
2054 impl CompleteData {
2055 #[inline(always)]
2056 fn max_ordinal_present(&self) -> u64 {
2057 if let Some(_) = self.progress {
2058 return 2;
2059 }
2060 if let Some(_) = self.info {
2061 return 1;
2062 }
2063 0
2064 }
2065 }
2066
2067 impl fidl::encoding::ValueTypeMarker for CompleteData {
2068 type Borrowed<'a> = &'a Self;
2069 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2070 value
2071 }
2072 }
2073
2074 unsafe impl fidl::encoding::TypeMarker for CompleteData {
2075 type Owned = Self;
2076
2077 #[inline(always)]
2078 fn inline_align(_context: fidl::encoding::Context) -> usize {
2079 8
2080 }
2081
2082 #[inline(always)]
2083 fn inline_size(_context: fidl::encoding::Context) -> usize {
2084 16
2085 }
2086 }
2087
2088 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompleteData, D>
2089 for &CompleteData
2090 {
2091 unsafe fn encode(
2092 self,
2093 encoder: &mut fidl::encoding::Encoder<'_, D>,
2094 offset: usize,
2095 mut depth: fidl::encoding::Depth,
2096 ) -> fidl::Result<()> {
2097 encoder.debug_check_bounds::<CompleteData>(offset);
2098 let max_ordinal: u64 = self.max_ordinal_present();
2100 encoder.write_num(max_ordinal, offset);
2101 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2102 if max_ordinal == 0 {
2104 return Ok(());
2105 }
2106 depth.increment()?;
2107 let envelope_size = 8;
2108 let bytes_len = max_ordinal as usize * envelope_size;
2109 #[allow(unused_variables)]
2110 let offset = encoder.out_of_line_offset(bytes_len);
2111 let mut _prev_end_offset: usize = 0;
2112 if 1 > max_ordinal {
2113 return Ok(());
2114 }
2115
2116 let cur_offset: usize = (1 - 1) * envelope_size;
2119
2120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2122
2123 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2128 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2129 encoder,
2130 offset + cur_offset,
2131 depth,
2132 )?;
2133
2134 _prev_end_offset = cur_offset + envelope_size;
2135 if 2 > max_ordinal {
2136 return Ok(());
2137 }
2138
2139 let cur_offset: usize = (2 - 1) * envelope_size;
2142
2143 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2145
2146 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2151 self.progress
2152 .as_ref()
2153 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2154 encoder,
2155 offset + cur_offset,
2156 depth,
2157 )?;
2158
2159 _prev_end_offset = cur_offset + envelope_size;
2160
2161 Ok(())
2162 }
2163 }
2164
2165 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompleteData {
2166 #[inline(always)]
2167 fn new_empty() -> Self {
2168 Self::default()
2169 }
2170
2171 unsafe fn decode(
2172 &mut self,
2173 decoder: &mut fidl::encoding::Decoder<'_, D>,
2174 offset: usize,
2175 mut depth: fidl::encoding::Depth,
2176 ) -> fidl::Result<()> {
2177 decoder.debug_check_bounds::<Self>(offset);
2178 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2179 None => return Err(fidl::Error::NotNullable),
2180 Some(len) => len,
2181 };
2182 if len == 0 {
2184 return Ok(());
2185 };
2186 depth.increment()?;
2187 let envelope_size = 8;
2188 let bytes_len = len * envelope_size;
2189 let offset = decoder.out_of_line_offset(bytes_len)?;
2190 let mut _next_ordinal_to_read = 0;
2192 let mut next_offset = offset;
2193 let end_offset = offset + bytes_len;
2194 _next_ordinal_to_read += 1;
2195 if next_offset >= end_offset {
2196 return Ok(());
2197 }
2198
2199 while _next_ordinal_to_read < 1 {
2201 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2202 _next_ordinal_to_read += 1;
2203 next_offset += envelope_size;
2204 }
2205
2206 let next_out_of_line = decoder.next_out_of_line();
2207 let handles_before = decoder.remaining_handles();
2208 if let Some((inlined, num_bytes, num_handles)) =
2209 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2210 {
2211 let member_inline_size =
2212 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2213 if inlined != (member_inline_size <= 4) {
2214 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2215 }
2216 let inner_offset;
2217 let mut inner_depth = depth.clone();
2218 if inlined {
2219 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2220 inner_offset = next_offset;
2221 } else {
2222 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2223 inner_depth.increment()?;
2224 }
2225 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2226 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2227 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2228 {
2229 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2230 }
2231 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2232 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2233 }
2234 }
2235
2236 next_offset += envelope_size;
2237 _next_ordinal_to_read += 1;
2238 if next_offset >= end_offset {
2239 return Ok(());
2240 }
2241
2242 while _next_ordinal_to_read < 2 {
2244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2245 _next_ordinal_to_read += 1;
2246 next_offset += envelope_size;
2247 }
2248
2249 let next_out_of_line = decoder.next_out_of_line();
2250 let handles_before = decoder.remaining_handles();
2251 if let Some((inlined, num_bytes, num_handles)) =
2252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2253 {
2254 let member_inline_size =
2255 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2256 decoder.context,
2257 );
2258 if inlined != (member_inline_size <= 4) {
2259 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2260 }
2261 let inner_offset;
2262 let mut inner_depth = depth.clone();
2263 if inlined {
2264 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2265 inner_offset = next_offset;
2266 } else {
2267 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2268 inner_depth.increment()?;
2269 }
2270 let val_ref =
2271 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2272 fidl::decode!(
2273 InstallationProgress,
2274 D,
2275 val_ref,
2276 decoder,
2277 inner_offset,
2278 inner_depth
2279 )?;
2280 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2281 {
2282 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2283 }
2284 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2285 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2286 }
2287 }
2288
2289 next_offset += envelope_size;
2290
2291 while next_offset < end_offset {
2293 _next_ordinal_to_read += 1;
2294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2295 next_offset += envelope_size;
2296 }
2297
2298 Ok(())
2299 }
2300 }
2301
2302 impl DeferRebootData {
2303 #[inline(always)]
2304 fn max_ordinal_present(&self) -> u64 {
2305 if let Some(_) = self.progress {
2306 return 2;
2307 }
2308 if let Some(_) = self.info {
2309 return 1;
2310 }
2311 0
2312 }
2313 }
2314
2315 impl fidl::encoding::ValueTypeMarker for DeferRebootData {
2316 type Borrowed<'a> = &'a Self;
2317 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2318 value
2319 }
2320 }
2321
2322 unsafe impl fidl::encoding::TypeMarker for DeferRebootData {
2323 type Owned = Self;
2324
2325 #[inline(always)]
2326 fn inline_align(_context: fidl::encoding::Context) -> usize {
2327 8
2328 }
2329
2330 #[inline(always)]
2331 fn inline_size(_context: fidl::encoding::Context) -> usize {
2332 16
2333 }
2334 }
2335
2336 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeferRebootData, D>
2337 for &DeferRebootData
2338 {
2339 unsafe fn encode(
2340 self,
2341 encoder: &mut fidl::encoding::Encoder<'_, D>,
2342 offset: usize,
2343 mut depth: fidl::encoding::Depth,
2344 ) -> fidl::Result<()> {
2345 encoder.debug_check_bounds::<DeferRebootData>(offset);
2346 let max_ordinal: u64 = self.max_ordinal_present();
2348 encoder.write_num(max_ordinal, offset);
2349 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2350 if max_ordinal == 0 {
2352 return Ok(());
2353 }
2354 depth.increment()?;
2355 let envelope_size = 8;
2356 let bytes_len = max_ordinal as usize * envelope_size;
2357 #[allow(unused_variables)]
2358 let offset = encoder.out_of_line_offset(bytes_len);
2359 let mut _prev_end_offset: usize = 0;
2360 if 1 > max_ordinal {
2361 return Ok(());
2362 }
2363
2364 let cur_offset: usize = (1 - 1) * envelope_size;
2367
2368 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2370
2371 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2376 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2377 encoder,
2378 offset + cur_offset,
2379 depth,
2380 )?;
2381
2382 _prev_end_offset = cur_offset + envelope_size;
2383 if 2 > max_ordinal {
2384 return Ok(());
2385 }
2386
2387 let cur_offset: usize = (2 - 1) * envelope_size;
2390
2391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2393
2394 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2399 self.progress
2400 .as_ref()
2401 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2402 encoder,
2403 offset + cur_offset,
2404 depth,
2405 )?;
2406
2407 _prev_end_offset = cur_offset + envelope_size;
2408
2409 Ok(())
2410 }
2411 }
2412
2413 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeferRebootData {
2414 #[inline(always)]
2415 fn new_empty() -> Self {
2416 Self::default()
2417 }
2418
2419 unsafe fn decode(
2420 &mut self,
2421 decoder: &mut fidl::encoding::Decoder<'_, D>,
2422 offset: usize,
2423 mut depth: fidl::encoding::Depth,
2424 ) -> fidl::Result<()> {
2425 decoder.debug_check_bounds::<Self>(offset);
2426 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2427 None => return Err(fidl::Error::NotNullable),
2428 Some(len) => len,
2429 };
2430 if len == 0 {
2432 return Ok(());
2433 };
2434 depth.increment()?;
2435 let envelope_size = 8;
2436 let bytes_len = len * envelope_size;
2437 let offset = decoder.out_of_line_offset(bytes_len)?;
2438 let mut _next_ordinal_to_read = 0;
2440 let mut next_offset = offset;
2441 let end_offset = offset + bytes_len;
2442 _next_ordinal_to_read += 1;
2443 if next_offset >= end_offset {
2444 return Ok(());
2445 }
2446
2447 while _next_ordinal_to_read < 1 {
2449 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2450 _next_ordinal_to_read += 1;
2451 next_offset += envelope_size;
2452 }
2453
2454 let next_out_of_line = decoder.next_out_of_line();
2455 let handles_before = decoder.remaining_handles();
2456 if let Some((inlined, num_bytes, num_handles)) =
2457 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2458 {
2459 let member_inline_size =
2460 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2461 if inlined != (member_inline_size <= 4) {
2462 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2463 }
2464 let inner_offset;
2465 let mut inner_depth = depth.clone();
2466 if inlined {
2467 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2468 inner_offset = next_offset;
2469 } else {
2470 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2471 inner_depth.increment()?;
2472 }
2473 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2474 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2475 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2476 {
2477 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2478 }
2479 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2480 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2481 }
2482 }
2483
2484 next_offset += envelope_size;
2485 _next_ordinal_to_read += 1;
2486 if next_offset >= end_offset {
2487 return Ok(());
2488 }
2489
2490 while _next_ordinal_to_read < 2 {
2492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2493 _next_ordinal_to_read += 1;
2494 next_offset += envelope_size;
2495 }
2496
2497 let next_out_of_line = decoder.next_out_of_line();
2498 let handles_before = decoder.remaining_handles();
2499 if let Some((inlined, num_bytes, num_handles)) =
2500 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2501 {
2502 let member_inline_size =
2503 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2504 decoder.context,
2505 );
2506 if inlined != (member_inline_size <= 4) {
2507 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2508 }
2509 let inner_offset;
2510 let mut inner_depth = depth.clone();
2511 if inlined {
2512 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2513 inner_offset = next_offset;
2514 } else {
2515 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2516 inner_depth.increment()?;
2517 }
2518 let val_ref =
2519 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2520 fidl::decode!(
2521 InstallationProgress,
2522 D,
2523 val_ref,
2524 decoder,
2525 inner_offset,
2526 inner_depth
2527 )?;
2528 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2529 {
2530 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2531 }
2532 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2533 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2534 }
2535 }
2536
2537 next_offset += envelope_size;
2538
2539 while next_offset < end_offset {
2541 _next_ordinal_to_read += 1;
2542 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2543 next_offset += envelope_size;
2544 }
2545
2546 Ok(())
2547 }
2548 }
2549
2550 impl FailCommitData {
2551 #[inline(always)]
2552 fn max_ordinal_present(&self) -> u64 {
2553 if let Some(_) = self.progress {
2554 return 2;
2555 }
2556 if let Some(_) = self.info {
2557 return 1;
2558 }
2559 0
2560 }
2561 }
2562
2563 impl fidl::encoding::ValueTypeMarker for FailCommitData {
2564 type Borrowed<'a> = &'a Self;
2565 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2566 value
2567 }
2568 }
2569
2570 unsafe impl fidl::encoding::TypeMarker for FailCommitData {
2571 type Owned = Self;
2572
2573 #[inline(always)]
2574 fn inline_align(_context: fidl::encoding::Context) -> usize {
2575 8
2576 }
2577
2578 #[inline(always)]
2579 fn inline_size(_context: fidl::encoding::Context) -> usize {
2580 16
2581 }
2582 }
2583
2584 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailCommitData, D>
2585 for &FailCommitData
2586 {
2587 unsafe fn encode(
2588 self,
2589 encoder: &mut fidl::encoding::Encoder<'_, D>,
2590 offset: usize,
2591 mut depth: fidl::encoding::Depth,
2592 ) -> fidl::Result<()> {
2593 encoder.debug_check_bounds::<FailCommitData>(offset);
2594 let max_ordinal: u64 = self.max_ordinal_present();
2596 encoder.write_num(max_ordinal, offset);
2597 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2598 if max_ordinal == 0 {
2600 return Ok(());
2601 }
2602 depth.increment()?;
2603 let envelope_size = 8;
2604 let bytes_len = max_ordinal as usize * envelope_size;
2605 #[allow(unused_variables)]
2606 let offset = encoder.out_of_line_offset(bytes_len);
2607 let mut _prev_end_offset: usize = 0;
2608 if 1 > max_ordinal {
2609 return Ok(());
2610 }
2611
2612 let cur_offset: usize = (1 - 1) * envelope_size;
2615
2616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2618
2619 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2624 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2625 encoder,
2626 offset + cur_offset,
2627 depth,
2628 )?;
2629
2630 _prev_end_offset = cur_offset + envelope_size;
2631 if 2 > max_ordinal {
2632 return Ok(());
2633 }
2634
2635 let cur_offset: usize = (2 - 1) * envelope_size;
2638
2639 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2641
2642 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2647 self.progress
2648 .as_ref()
2649 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2650 encoder,
2651 offset + cur_offset,
2652 depth,
2653 )?;
2654
2655 _prev_end_offset = cur_offset + envelope_size;
2656
2657 Ok(())
2658 }
2659 }
2660
2661 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailCommitData {
2662 #[inline(always)]
2663 fn new_empty() -> Self {
2664 Self::default()
2665 }
2666
2667 unsafe fn decode(
2668 &mut self,
2669 decoder: &mut fidl::encoding::Decoder<'_, D>,
2670 offset: usize,
2671 mut depth: fidl::encoding::Depth,
2672 ) -> fidl::Result<()> {
2673 decoder.debug_check_bounds::<Self>(offset);
2674 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2675 None => return Err(fidl::Error::NotNullable),
2676 Some(len) => len,
2677 };
2678 if len == 0 {
2680 return Ok(());
2681 };
2682 depth.increment()?;
2683 let envelope_size = 8;
2684 let bytes_len = len * envelope_size;
2685 let offset = decoder.out_of_line_offset(bytes_len)?;
2686 let mut _next_ordinal_to_read = 0;
2688 let mut next_offset = offset;
2689 let end_offset = offset + bytes_len;
2690 _next_ordinal_to_read += 1;
2691 if next_offset >= end_offset {
2692 return Ok(());
2693 }
2694
2695 while _next_ordinal_to_read < 1 {
2697 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2698 _next_ordinal_to_read += 1;
2699 next_offset += envelope_size;
2700 }
2701
2702 let next_out_of_line = decoder.next_out_of_line();
2703 let handles_before = decoder.remaining_handles();
2704 if let Some((inlined, num_bytes, num_handles)) =
2705 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2706 {
2707 let member_inline_size =
2708 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2709 if inlined != (member_inline_size <= 4) {
2710 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2711 }
2712 let inner_offset;
2713 let mut inner_depth = depth.clone();
2714 if inlined {
2715 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2716 inner_offset = next_offset;
2717 } else {
2718 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2719 inner_depth.increment()?;
2720 }
2721 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2722 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2723 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2724 {
2725 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2726 }
2727 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2728 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2729 }
2730 }
2731
2732 next_offset += envelope_size;
2733 _next_ordinal_to_read += 1;
2734 if next_offset >= end_offset {
2735 return Ok(());
2736 }
2737
2738 while _next_ordinal_to_read < 2 {
2740 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2741 _next_ordinal_to_read += 1;
2742 next_offset += envelope_size;
2743 }
2744
2745 let next_out_of_line = decoder.next_out_of_line();
2746 let handles_before = decoder.remaining_handles();
2747 if let Some((inlined, num_bytes, num_handles)) =
2748 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2749 {
2750 let member_inline_size =
2751 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2752 decoder.context,
2753 );
2754 if inlined != (member_inline_size <= 4) {
2755 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2756 }
2757 let inner_offset;
2758 let mut inner_depth = depth.clone();
2759 if inlined {
2760 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2761 inner_offset = next_offset;
2762 } else {
2763 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2764 inner_depth.increment()?;
2765 }
2766 let val_ref =
2767 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2768 fidl::decode!(
2769 InstallationProgress,
2770 D,
2771 val_ref,
2772 decoder,
2773 inner_offset,
2774 inner_depth
2775 )?;
2776 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2777 {
2778 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2779 }
2780 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2781 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2782 }
2783 }
2784
2785 next_offset += envelope_size;
2786
2787 while next_offset < end_offset {
2789 _next_ordinal_to_read += 1;
2790 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2791 next_offset += envelope_size;
2792 }
2793
2794 Ok(())
2795 }
2796 }
2797
2798 impl FailFetchData {
2799 #[inline(always)]
2800 fn max_ordinal_present(&self) -> u64 {
2801 if let Some(_) = self.reason {
2802 return 3;
2803 }
2804 if let Some(_) = self.progress {
2805 return 2;
2806 }
2807 if let Some(_) = self.info {
2808 return 1;
2809 }
2810 0
2811 }
2812 }
2813
2814 impl fidl::encoding::ValueTypeMarker for FailFetchData {
2815 type Borrowed<'a> = &'a Self;
2816 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2817 value
2818 }
2819 }
2820
2821 unsafe impl fidl::encoding::TypeMarker for FailFetchData {
2822 type Owned = Self;
2823
2824 #[inline(always)]
2825 fn inline_align(_context: fidl::encoding::Context) -> usize {
2826 8
2827 }
2828
2829 #[inline(always)]
2830 fn inline_size(_context: fidl::encoding::Context) -> usize {
2831 16
2832 }
2833 }
2834
2835 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailFetchData, D>
2836 for &FailFetchData
2837 {
2838 unsafe fn encode(
2839 self,
2840 encoder: &mut fidl::encoding::Encoder<'_, D>,
2841 offset: usize,
2842 mut depth: fidl::encoding::Depth,
2843 ) -> fidl::Result<()> {
2844 encoder.debug_check_bounds::<FailFetchData>(offset);
2845 let max_ordinal: u64 = self.max_ordinal_present();
2847 encoder.write_num(max_ordinal, offset);
2848 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2849 if max_ordinal == 0 {
2851 return Ok(());
2852 }
2853 depth.increment()?;
2854 let envelope_size = 8;
2855 let bytes_len = max_ordinal as usize * envelope_size;
2856 #[allow(unused_variables)]
2857 let offset = encoder.out_of_line_offset(bytes_len);
2858 let mut _prev_end_offset: usize = 0;
2859 if 1 > max_ordinal {
2860 return Ok(());
2861 }
2862
2863 let cur_offset: usize = (1 - 1) * envelope_size;
2866
2867 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2869
2870 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2875 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2876 encoder,
2877 offset + cur_offset,
2878 depth,
2879 )?;
2880
2881 _prev_end_offset = cur_offset + envelope_size;
2882 if 2 > max_ordinal {
2883 return Ok(());
2884 }
2885
2886 let cur_offset: usize = (2 - 1) * envelope_size;
2889
2890 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2892
2893 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2898 self.progress
2899 .as_ref()
2900 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2901 encoder,
2902 offset + cur_offset,
2903 depth,
2904 )?;
2905
2906 _prev_end_offset = cur_offset + envelope_size;
2907 if 3 > max_ordinal {
2908 return Ok(());
2909 }
2910
2911 let cur_offset: usize = (3 - 1) * envelope_size;
2914
2915 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2917
2918 fidl::encoding::encode_in_envelope_optional::<FetchFailureReason, D>(
2923 self.reason
2924 .as_ref()
2925 .map(<FetchFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
2926 encoder,
2927 offset + cur_offset,
2928 depth,
2929 )?;
2930
2931 _prev_end_offset = cur_offset + envelope_size;
2932
2933 Ok(())
2934 }
2935 }
2936
2937 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailFetchData {
2938 #[inline(always)]
2939 fn new_empty() -> Self {
2940 Self::default()
2941 }
2942
2943 unsafe fn decode(
2944 &mut self,
2945 decoder: &mut fidl::encoding::Decoder<'_, D>,
2946 offset: usize,
2947 mut depth: fidl::encoding::Depth,
2948 ) -> fidl::Result<()> {
2949 decoder.debug_check_bounds::<Self>(offset);
2950 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2951 None => return Err(fidl::Error::NotNullable),
2952 Some(len) => len,
2953 };
2954 if len == 0 {
2956 return Ok(());
2957 };
2958 depth.increment()?;
2959 let envelope_size = 8;
2960 let bytes_len = len * envelope_size;
2961 let offset = decoder.out_of_line_offset(bytes_len)?;
2962 let mut _next_ordinal_to_read = 0;
2964 let mut next_offset = offset;
2965 let end_offset = offset + bytes_len;
2966 _next_ordinal_to_read += 1;
2967 if next_offset >= end_offset {
2968 return Ok(());
2969 }
2970
2971 while _next_ordinal_to_read < 1 {
2973 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2974 _next_ordinal_to_read += 1;
2975 next_offset += envelope_size;
2976 }
2977
2978 let next_out_of_line = decoder.next_out_of_line();
2979 let handles_before = decoder.remaining_handles();
2980 if let Some((inlined, num_bytes, num_handles)) =
2981 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2982 {
2983 let member_inline_size =
2984 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2985 if inlined != (member_inline_size <= 4) {
2986 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2987 }
2988 let inner_offset;
2989 let mut inner_depth = depth.clone();
2990 if inlined {
2991 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2992 inner_offset = next_offset;
2993 } else {
2994 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2995 inner_depth.increment()?;
2996 }
2997 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2998 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2999 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3000 {
3001 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3002 }
3003 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3004 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3005 }
3006 }
3007
3008 next_offset += envelope_size;
3009 _next_ordinal_to_read += 1;
3010 if next_offset >= end_offset {
3011 return Ok(());
3012 }
3013
3014 while _next_ordinal_to_read < 2 {
3016 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3017 _next_ordinal_to_read += 1;
3018 next_offset += envelope_size;
3019 }
3020
3021 let next_out_of_line = decoder.next_out_of_line();
3022 let handles_before = decoder.remaining_handles();
3023 if let Some((inlined, num_bytes, num_handles)) =
3024 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3025 {
3026 let member_inline_size =
3027 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3028 decoder.context,
3029 );
3030 if inlined != (member_inline_size <= 4) {
3031 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3032 }
3033 let inner_offset;
3034 let mut inner_depth = depth.clone();
3035 if inlined {
3036 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3037 inner_offset = next_offset;
3038 } else {
3039 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3040 inner_depth.increment()?;
3041 }
3042 let val_ref =
3043 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3044 fidl::decode!(
3045 InstallationProgress,
3046 D,
3047 val_ref,
3048 decoder,
3049 inner_offset,
3050 inner_depth
3051 )?;
3052 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3053 {
3054 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3055 }
3056 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3057 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3058 }
3059 }
3060
3061 next_offset += envelope_size;
3062 _next_ordinal_to_read += 1;
3063 if next_offset >= end_offset {
3064 return Ok(());
3065 }
3066
3067 while _next_ordinal_to_read < 3 {
3069 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3070 _next_ordinal_to_read += 1;
3071 next_offset += envelope_size;
3072 }
3073
3074 let next_out_of_line = decoder.next_out_of_line();
3075 let handles_before = decoder.remaining_handles();
3076 if let Some((inlined, num_bytes, num_handles)) =
3077 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3078 {
3079 let member_inline_size =
3080 <FetchFailureReason as fidl::encoding::TypeMarker>::inline_size(
3081 decoder.context,
3082 );
3083 if inlined != (member_inline_size <= 4) {
3084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3085 }
3086 let inner_offset;
3087 let mut inner_depth = depth.clone();
3088 if inlined {
3089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3090 inner_offset = next_offset;
3091 } else {
3092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3093 inner_depth.increment()?;
3094 }
3095 let val_ref =
3096 self.reason.get_or_insert_with(|| fidl::new_empty!(FetchFailureReason, D));
3097 fidl::decode!(FetchFailureReason, D, val_ref, decoder, inner_offset, inner_depth)?;
3098 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3099 {
3100 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3101 }
3102 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3103 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3104 }
3105 }
3106
3107 next_offset += envelope_size;
3108
3109 while next_offset < end_offset {
3111 _next_ordinal_to_read += 1;
3112 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3113 next_offset += envelope_size;
3114 }
3115
3116 Ok(())
3117 }
3118 }
3119
3120 impl FailPrepareData {
3121 #[inline(always)]
3122 fn max_ordinal_present(&self) -> u64 {
3123 if let Some(_) = self.reason {
3124 return 1;
3125 }
3126 0
3127 }
3128 }
3129
3130 impl fidl::encoding::ValueTypeMarker for FailPrepareData {
3131 type Borrowed<'a> = &'a Self;
3132 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3133 value
3134 }
3135 }
3136
3137 unsafe impl fidl::encoding::TypeMarker for FailPrepareData {
3138 type Owned = Self;
3139
3140 #[inline(always)]
3141 fn inline_align(_context: fidl::encoding::Context) -> usize {
3142 8
3143 }
3144
3145 #[inline(always)]
3146 fn inline_size(_context: fidl::encoding::Context) -> usize {
3147 16
3148 }
3149 }
3150
3151 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailPrepareData, D>
3152 for &FailPrepareData
3153 {
3154 unsafe fn encode(
3155 self,
3156 encoder: &mut fidl::encoding::Encoder<'_, D>,
3157 offset: usize,
3158 mut depth: fidl::encoding::Depth,
3159 ) -> fidl::Result<()> {
3160 encoder.debug_check_bounds::<FailPrepareData>(offset);
3161 let max_ordinal: u64 = self.max_ordinal_present();
3163 encoder.write_num(max_ordinal, offset);
3164 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3165 if max_ordinal == 0 {
3167 return Ok(());
3168 }
3169 depth.increment()?;
3170 let envelope_size = 8;
3171 let bytes_len = max_ordinal as usize * envelope_size;
3172 #[allow(unused_variables)]
3173 let offset = encoder.out_of_line_offset(bytes_len);
3174 let mut _prev_end_offset: usize = 0;
3175 if 1 > max_ordinal {
3176 return Ok(());
3177 }
3178
3179 let cur_offset: usize = (1 - 1) * envelope_size;
3182
3183 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3185
3186 fidl::encoding::encode_in_envelope_optional::<PrepareFailureReason, D>(
3191 self.reason
3192 .as_ref()
3193 .map(<PrepareFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
3194 encoder,
3195 offset + cur_offset,
3196 depth,
3197 )?;
3198
3199 _prev_end_offset = cur_offset + envelope_size;
3200
3201 Ok(())
3202 }
3203 }
3204
3205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailPrepareData {
3206 #[inline(always)]
3207 fn new_empty() -> Self {
3208 Self::default()
3209 }
3210
3211 unsafe fn decode(
3212 &mut self,
3213 decoder: &mut fidl::encoding::Decoder<'_, D>,
3214 offset: usize,
3215 mut depth: fidl::encoding::Depth,
3216 ) -> fidl::Result<()> {
3217 decoder.debug_check_bounds::<Self>(offset);
3218 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3219 None => return Err(fidl::Error::NotNullable),
3220 Some(len) => len,
3221 };
3222 if len == 0 {
3224 return Ok(());
3225 };
3226 depth.increment()?;
3227 let envelope_size = 8;
3228 let bytes_len = len * envelope_size;
3229 let offset = decoder.out_of_line_offset(bytes_len)?;
3230 let mut _next_ordinal_to_read = 0;
3232 let mut next_offset = offset;
3233 let end_offset = offset + bytes_len;
3234 _next_ordinal_to_read += 1;
3235 if next_offset >= end_offset {
3236 return Ok(());
3237 }
3238
3239 while _next_ordinal_to_read < 1 {
3241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3242 _next_ordinal_to_read += 1;
3243 next_offset += envelope_size;
3244 }
3245
3246 let next_out_of_line = decoder.next_out_of_line();
3247 let handles_before = decoder.remaining_handles();
3248 if let Some((inlined, num_bytes, num_handles)) =
3249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3250 {
3251 let member_inline_size =
3252 <PrepareFailureReason as fidl::encoding::TypeMarker>::inline_size(
3253 decoder.context,
3254 );
3255 if inlined != (member_inline_size <= 4) {
3256 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3257 }
3258 let inner_offset;
3259 let mut inner_depth = depth.clone();
3260 if inlined {
3261 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3262 inner_offset = next_offset;
3263 } else {
3264 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3265 inner_depth.increment()?;
3266 }
3267 let val_ref =
3268 self.reason.get_or_insert_with(|| fidl::new_empty!(PrepareFailureReason, D));
3269 fidl::decode!(
3270 PrepareFailureReason,
3271 D,
3272 val_ref,
3273 decoder,
3274 inner_offset,
3275 inner_depth
3276 )?;
3277 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3278 {
3279 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3280 }
3281 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3282 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3283 }
3284 }
3285
3286 next_offset += envelope_size;
3287
3288 while next_offset < end_offset {
3290 _next_ordinal_to_read += 1;
3291 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3292 next_offset += envelope_size;
3293 }
3294
3295 Ok(())
3296 }
3297 }
3298
3299 impl FailStageData {
3300 #[inline(always)]
3301 fn max_ordinal_present(&self) -> u64 {
3302 if let Some(_) = self.reason {
3303 return 3;
3304 }
3305 if let Some(_) = self.progress {
3306 return 2;
3307 }
3308 if let Some(_) = self.info {
3309 return 1;
3310 }
3311 0
3312 }
3313 }
3314
3315 impl fidl::encoding::ValueTypeMarker for FailStageData {
3316 type Borrowed<'a> = &'a Self;
3317 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3318 value
3319 }
3320 }
3321
3322 unsafe impl fidl::encoding::TypeMarker for FailStageData {
3323 type Owned = Self;
3324
3325 #[inline(always)]
3326 fn inline_align(_context: fidl::encoding::Context) -> usize {
3327 8
3328 }
3329
3330 #[inline(always)]
3331 fn inline_size(_context: fidl::encoding::Context) -> usize {
3332 16
3333 }
3334 }
3335
3336 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailStageData, D>
3337 for &FailStageData
3338 {
3339 unsafe fn encode(
3340 self,
3341 encoder: &mut fidl::encoding::Encoder<'_, D>,
3342 offset: usize,
3343 mut depth: fidl::encoding::Depth,
3344 ) -> fidl::Result<()> {
3345 encoder.debug_check_bounds::<FailStageData>(offset);
3346 let max_ordinal: u64 = self.max_ordinal_present();
3348 encoder.write_num(max_ordinal, offset);
3349 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3350 if max_ordinal == 0 {
3352 return Ok(());
3353 }
3354 depth.increment()?;
3355 let envelope_size = 8;
3356 let bytes_len = max_ordinal as usize * envelope_size;
3357 #[allow(unused_variables)]
3358 let offset = encoder.out_of_line_offset(bytes_len);
3359 let mut _prev_end_offset: usize = 0;
3360 if 1 > max_ordinal {
3361 return Ok(());
3362 }
3363
3364 let cur_offset: usize = (1 - 1) * envelope_size;
3367
3368 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3370
3371 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
3376 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
3377 encoder,
3378 offset + cur_offset,
3379 depth,
3380 )?;
3381
3382 _prev_end_offset = cur_offset + envelope_size;
3383 if 2 > max_ordinal {
3384 return Ok(());
3385 }
3386
3387 let cur_offset: usize = (2 - 1) * envelope_size;
3390
3391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3393
3394 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
3399 self.progress
3400 .as_ref()
3401 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
3402 encoder,
3403 offset + cur_offset,
3404 depth,
3405 )?;
3406
3407 _prev_end_offset = cur_offset + envelope_size;
3408 if 3 > max_ordinal {
3409 return Ok(());
3410 }
3411
3412 let cur_offset: usize = (3 - 1) * envelope_size;
3415
3416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3418
3419 fidl::encoding::encode_in_envelope_optional::<StageFailureReason, D>(
3424 self.reason
3425 .as_ref()
3426 .map(<StageFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
3427 encoder,
3428 offset + cur_offset,
3429 depth,
3430 )?;
3431
3432 _prev_end_offset = cur_offset + envelope_size;
3433
3434 Ok(())
3435 }
3436 }
3437
3438 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailStageData {
3439 #[inline(always)]
3440 fn new_empty() -> Self {
3441 Self::default()
3442 }
3443
3444 unsafe fn decode(
3445 &mut self,
3446 decoder: &mut fidl::encoding::Decoder<'_, D>,
3447 offset: usize,
3448 mut depth: fidl::encoding::Depth,
3449 ) -> fidl::Result<()> {
3450 decoder.debug_check_bounds::<Self>(offset);
3451 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3452 None => return Err(fidl::Error::NotNullable),
3453 Some(len) => len,
3454 };
3455 if len == 0 {
3457 return Ok(());
3458 };
3459 depth.increment()?;
3460 let envelope_size = 8;
3461 let bytes_len = len * envelope_size;
3462 let offset = decoder.out_of_line_offset(bytes_len)?;
3463 let mut _next_ordinal_to_read = 0;
3465 let mut next_offset = offset;
3466 let end_offset = offset + bytes_len;
3467 _next_ordinal_to_read += 1;
3468 if next_offset >= end_offset {
3469 return Ok(());
3470 }
3471
3472 while _next_ordinal_to_read < 1 {
3474 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3475 _next_ordinal_to_read += 1;
3476 next_offset += envelope_size;
3477 }
3478
3479 let next_out_of_line = decoder.next_out_of_line();
3480 let handles_before = decoder.remaining_handles();
3481 if let Some((inlined, num_bytes, num_handles)) =
3482 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3483 {
3484 let member_inline_size =
3485 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3486 if inlined != (member_inline_size <= 4) {
3487 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3488 }
3489 let inner_offset;
3490 let mut inner_depth = depth.clone();
3491 if inlined {
3492 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3493 inner_offset = next_offset;
3494 } else {
3495 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3496 inner_depth.increment()?;
3497 }
3498 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
3499 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3500 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3501 {
3502 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3503 }
3504 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3505 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3506 }
3507 }
3508
3509 next_offset += envelope_size;
3510 _next_ordinal_to_read += 1;
3511 if next_offset >= end_offset {
3512 return Ok(());
3513 }
3514
3515 while _next_ordinal_to_read < 2 {
3517 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3518 _next_ordinal_to_read += 1;
3519 next_offset += envelope_size;
3520 }
3521
3522 let next_out_of_line = decoder.next_out_of_line();
3523 let handles_before = decoder.remaining_handles();
3524 if let Some((inlined, num_bytes, num_handles)) =
3525 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3526 {
3527 let member_inline_size =
3528 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3529 decoder.context,
3530 );
3531 if inlined != (member_inline_size <= 4) {
3532 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3533 }
3534 let inner_offset;
3535 let mut inner_depth = depth.clone();
3536 if inlined {
3537 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3538 inner_offset = next_offset;
3539 } else {
3540 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3541 inner_depth.increment()?;
3542 }
3543 let val_ref =
3544 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3545 fidl::decode!(
3546 InstallationProgress,
3547 D,
3548 val_ref,
3549 decoder,
3550 inner_offset,
3551 inner_depth
3552 )?;
3553 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3554 {
3555 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3556 }
3557 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3558 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3559 }
3560 }
3561
3562 next_offset += envelope_size;
3563 _next_ordinal_to_read += 1;
3564 if next_offset >= end_offset {
3565 return Ok(());
3566 }
3567
3568 while _next_ordinal_to_read < 3 {
3570 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3571 _next_ordinal_to_read += 1;
3572 next_offset += envelope_size;
3573 }
3574
3575 let next_out_of_line = decoder.next_out_of_line();
3576 let handles_before = decoder.remaining_handles();
3577 if let Some((inlined, num_bytes, num_handles)) =
3578 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3579 {
3580 let member_inline_size =
3581 <StageFailureReason as fidl::encoding::TypeMarker>::inline_size(
3582 decoder.context,
3583 );
3584 if inlined != (member_inline_size <= 4) {
3585 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3586 }
3587 let inner_offset;
3588 let mut inner_depth = depth.clone();
3589 if inlined {
3590 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3591 inner_offset = next_offset;
3592 } else {
3593 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3594 inner_depth.increment()?;
3595 }
3596 let val_ref =
3597 self.reason.get_or_insert_with(|| fidl::new_empty!(StageFailureReason, D));
3598 fidl::decode!(StageFailureReason, D, val_ref, decoder, inner_offset, inner_depth)?;
3599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3600 {
3601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3602 }
3603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3605 }
3606 }
3607
3608 next_offset += envelope_size;
3609
3610 while next_offset < end_offset {
3612 _next_ordinal_to_read += 1;
3613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3614 next_offset += envelope_size;
3615 }
3616
3617 Ok(())
3618 }
3619 }
3620
3621 impl FetchData {
3622 #[inline(always)]
3623 fn max_ordinal_present(&self) -> u64 {
3624 if let Some(_) = self.progress {
3625 return 2;
3626 }
3627 if let Some(_) = self.info {
3628 return 1;
3629 }
3630 0
3631 }
3632 }
3633
3634 impl fidl::encoding::ValueTypeMarker for FetchData {
3635 type Borrowed<'a> = &'a Self;
3636 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3637 value
3638 }
3639 }
3640
3641 unsafe impl fidl::encoding::TypeMarker for FetchData {
3642 type Owned = Self;
3643
3644 #[inline(always)]
3645 fn inline_align(_context: fidl::encoding::Context) -> usize {
3646 8
3647 }
3648
3649 #[inline(always)]
3650 fn inline_size(_context: fidl::encoding::Context) -> usize {
3651 16
3652 }
3653 }
3654
3655 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FetchData, D>
3656 for &FetchData
3657 {
3658 unsafe fn encode(
3659 self,
3660 encoder: &mut fidl::encoding::Encoder<'_, D>,
3661 offset: usize,
3662 mut depth: fidl::encoding::Depth,
3663 ) -> fidl::Result<()> {
3664 encoder.debug_check_bounds::<FetchData>(offset);
3665 let max_ordinal: u64 = self.max_ordinal_present();
3667 encoder.write_num(max_ordinal, offset);
3668 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3669 if max_ordinal == 0 {
3671 return Ok(());
3672 }
3673 depth.increment()?;
3674 let envelope_size = 8;
3675 let bytes_len = max_ordinal as usize * envelope_size;
3676 #[allow(unused_variables)]
3677 let offset = encoder.out_of_line_offset(bytes_len);
3678 let mut _prev_end_offset: usize = 0;
3679 if 1 > max_ordinal {
3680 return Ok(());
3681 }
3682
3683 let cur_offset: usize = (1 - 1) * envelope_size;
3686
3687 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3689
3690 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
3695 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
3696 encoder,
3697 offset + cur_offset,
3698 depth,
3699 )?;
3700
3701 _prev_end_offset = cur_offset + envelope_size;
3702 if 2 > max_ordinal {
3703 return Ok(());
3704 }
3705
3706 let cur_offset: usize = (2 - 1) * envelope_size;
3709
3710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3712
3713 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
3718 self.progress
3719 .as_ref()
3720 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
3721 encoder,
3722 offset + cur_offset,
3723 depth,
3724 )?;
3725
3726 _prev_end_offset = cur_offset + envelope_size;
3727
3728 Ok(())
3729 }
3730 }
3731
3732 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FetchData {
3733 #[inline(always)]
3734 fn new_empty() -> Self {
3735 Self::default()
3736 }
3737
3738 unsafe fn decode(
3739 &mut self,
3740 decoder: &mut fidl::encoding::Decoder<'_, D>,
3741 offset: usize,
3742 mut depth: fidl::encoding::Depth,
3743 ) -> fidl::Result<()> {
3744 decoder.debug_check_bounds::<Self>(offset);
3745 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3746 None => return Err(fidl::Error::NotNullable),
3747 Some(len) => len,
3748 };
3749 if len == 0 {
3751 return Ok(());
3752 };
3753 depth.increment()?;
3754 let envelope_size = 8;
3755 let bytes_len = len * envelope_size;
3756 let offset = decoder.out_of_line_offset(bytes_len)?;
3757 let mut _next_ordinal_to_read = 0;
3759 let mut next_offset = offset;
3760 let end_offset = offset + bytes_len;
3761 _next_ordinal_to_read += 1;
3762 if next_offset >= end_offset {
3763 return Ok(());
3764 }
3765
3766 while _next_ordinal_to_read < 1 {
3768 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3769 _next_ordinal_to_read += 1;
3770 next_offset += envelope_size;
3771 }
3772
3773 let next_out_of_line = decoder.next_out_of_line();
3774 let handles_before = decoder.remaining_handles();
3775 if let Some((inlined, num_bytes, num_handles)) =
3776 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3777 {
3778 let member_inline_size =
3779 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3780 if inlined != (member_inline_size <= 4) {
3781 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3782 }
3783 let inner_offset;
3784 let mut inner_depth = depth.clone();
3785 if inlined {
3786 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3787 inner_offset = next_offset;
3788 } else {
3789 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3790 inner_depth.increment()?;
3791 }
3792 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
3793 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3794 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3795 {
3796 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3797 }
3798 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3799 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3800 }
3801 }
3802
3803 next_offset += envelope_size;
3804 _next_ordinal_to_read += 1;
3805 if next_offset >= end_offset {
3806 return Ok(());
3807 }
3808
3809 while _next_ordinal_to_read < 2 {
3811 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3812 _next_ordinal_to_read += 1;
3813 next_offset += envelope_size;
3814 }
3815
3816 let next_out_of_line = decoder.next_out_of_line();
3817 let handles_before = decoder.remaining_handles();
3818 if let Some((inlined, num_bytes, num_handles)) =
3819 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3820 {
3821 let member_inline_size =
3822 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3823 decoder.context,
3824 );
3825 if inlined != (member_inline_size <= 4) {
3826 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3827 }
3828 let inner_offset;
3829 let mut inner_depth = depth.clone();
3830 if inlined {
3831 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3832 inner_offset = next_offset;
3833 } else {
3834 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3835 inner_depth.increment()?;
3836 }
3837 let val_ref =
3838 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3839 fidl::decode!(
3840 InstallationProgress,
3841 D,
3842 val_ref,
3843 decoder,
3844 inner_offset,
3845 inner_depth
3846 )?;
3847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848 {
3849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850 }
3851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853 }
3854 }
3855
3856 next_offset += envelope_size;
3857
3858 while next_offset < end_offset {
3860 _next_ordinal_to_read += 1;
3861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3862 next_offset += envelope_size;
3863 }
3864
3865 Ok(())
3866 }
3867 }
3868
3869 impl InstallationProgress {
3870 #[inline(always)]
3871 fn max_ordinal_present(&self) -> u64 {
3872 if let Some(_) = self.bytes_downloaded {
3873 return 2;
3874 }
3875 if let Some(_) = self.fraction_completed {
3876 return 1;
3877 }
3878 0
3879 }
3880 }
3881
3882 impl fidl::encoding::ValueTypeMarker for InstallationProgress {
3883 type Borrowed<'a> = &'a Self;
3884 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3885 value
3886 }
3887 }
3888
3889 unsafe impl fidl::encoding::TypeMarker for InstallationProgress {
3890 type Owned = Self;
3891
3892 #[inline(always)]
3893 fn inline_align(_context: fidl::encoding::Context) -> usize {
3894 8
3895 }
3896
3897 #[inline(always)]
3898 fn inline_size(_context: fidl::encoding::Context) -> usize {
3899 16
3900 }
3901 }
3902
3903 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstallationProgress, D>
3904 for &InstallationProgress
3905 {
3906 unsafe fn encode(
3907 self,
3908 encoder: &mut fidl::encoding::Encoder<'_, D>,
3909 offset: usize,
3910 mut depth: fidl::encoding::Depth,
3911 ) -> fidl::Result<()> {
3912 encoder.debug_check_bounds::<InstallationProgress>(offset);
3913 let max_ordinal: u64 = self.max_ordinal_present();
3915 encoder.write_num(max_ordinal, offset);
3916 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3917 if max_ordinal == 0 {
3919 return Ok(());
3920 }
3921 depth.increment()?;
3922 let envelope_size = 8;
3923 let bytes_len = max_ordinal as usize * envelope_size;
3924 #[allow(unused_variables)]
3925 let offset = encoder.out_of_line_offset(bytes_len);
3926 let mut _prev_end_offset: usize = 0;
3927 if 1 > max_ordinal {
3928 return Ok(());
3929 }
3930
3931 let cur_offset: usize = (1 - 1) * envelope_size;
3934
3935 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3937
3938 fidl::encoding::encode_in_envelope_optional::<f32, D>(
3943 self.fraction_completed
3944 .as_ref()
3945 .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
3946 encoder,
3947 offset + cur_offset,
3948 depth,
3949 )?;
3950
3951 _prev_end_offset = cur_offset + envelope_size;
3952 if 2 > max_ordinal {
3953 return Ok(());
3954 }
3955
3956 let cur_offset: usize = (2 - 1) * envelope_size;
3959
3960 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3962
3963 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3968 self.bytes_downloaded
3969 .as_ref()
3970 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3971 encoder,
3972 offset + cur_offset,
3973 depth,
3974 )?;
3975
3976 _prev_end_offset = cur_offset + envelope_size;
3977
3978 Ok(())
3979 }
3980 }
3981
3982 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstallationProgress {
3983 #[inline(always)]
3984 fn new_empty() -> Self {
3985 Self::default()
3986 }
3987
3988 unsafe fn decode(
3989 &mut self,
3990 decoder: &mut fidl::encoding::Decoder<'_, D>,
3991 offset: usize,
3992 mut depth: fidl::encoding::Depth,
3993 ) -> fidl::Result<()> {
3994 decoder.debug_check_bounds::<Self>(offset);
3995 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3996 None => return Err(fidl::Error::NotNullable),
3997 Some(len) => len,
3998 };
3999 if len == 0 {
4001 return Ok(());
4002 };
4003 depth.increment()?;
4004 let envelope_size = 8;
4005 let bytes_len = len * envelope_size;
4006 let offset = decoder.out_of_line_offset(bytes_len)?;
4007 let mut _next_ordinal_to_read = 0;
4009 let mut next_offset = offset;
4010 let end_offset = offset + bytes_len;
4011 _next_ordinal_to_read += 1;
4012 if next_offset >= end_offset {
4013 return Ok(());
4014 }
4015
4016 while _next_ordinal_to_read < 1 {
4018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4019 _next_ordinal_to_read += 1;
4020 next_offset += envelope_size;
4021 }
4022
4023 let next_out_of_line = decoder.next_out_of_line();
4024 let handles_before = decoder.remaining_handles();
4025 if let Some((inlined, num_bytes, num_handles)) =
4026 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4027 {
4028 let member_inline_size =
4029 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4030 if inlined != (member_inline_size <= 4) {
4031 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4032 }
4033 let inner_offset;
4034 let mut inner_depth = depth.clone();
4035 if inlined {
4036 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4037 inner_offset = next_offset;
4038 } else {
4039 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4040 inner_depth.increment()?;
4041 }
4042 let val_ref =
4043 self.fraction_completed.get_or_insert_with(|| fidl::new_empty!(f32, D));
4044 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4045 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4046 {
4047 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4048 }
4049 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4050 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4051 }
4052 }
4053
4054 next_offset += envelope_size;
4055 _next_ordinal_to_read += 1;
4056 if next_offset >= end_offset {
4057 return Ok(());
4058 }
4059
4060 while _next_ordinal_to_read < 2 {
4062 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4063 _next_ordinal_to_read += 1;
4064 next_offset += envelope_size;
4065 }
4066
4067 let next_out_of_line = decoder.next_out_of_line();
4068 let handles_before = decoder.remaining_handles();
4069 if let Some((inlined, num_bytes, num_handles)) =
4070 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4071 {
4072 let member_inline_size =
4073 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4074 if inlined != (member_inline_size <= 4) {
4075 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4076 }
4077 let inner_offset;
4078 let mut inner_depth = depth.clone();
4079 if inlined {
4080 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4081 inner_offset = next_offset;
4082 } else {
4083 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4084 inner_depth.increment()?;
4085 }
4086 let val_ref = self.bytes_downloaded.get_or_insert_with(|| fidl::new_empty!(u64, D));
4087 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4088 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4089 {
4090 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4091 }
4092 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4093 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4094 }
4095 }
4096
4097 next_offset += envelope_size;
4098
4099 while next_offset < end_offset {
4101 _next_ordinal_to_read += 1;
4102 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4103 next_offset += envelope_size;
4104 }
4105
4106 Ok(())
4107 }
4108 }
4109
4110 impl Options {
4111 #[inline(always)]
4112 fn max_ordinal_present(&self) -> u64 {
4113 if let Some(_) = self.should_write_recovery {
4114 return 3;
4115 }
4116 if let Some(_) = self.allow_attach_to_existing_attempt {
4117 return 2;
4118 }
4119 if let Some(_) = self.initiator {
4120 return 1;
4121 }
4122 0
4123 }
4124 }
4125
4126 impl fidl::encoding::ValueTypeMarker for Options {
4127 type Borrowed<'a> = &'a Self;
4128 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4129 value
4130 }
4131 }
4132
4133 unsafe impl fidl::encoding::TypeMarker for Options {
4134 type Owned = Self;
4135
4136 #[inline(always)]
4137 fn inline_align(_context: fidl::encoding::Context) -> usize {
4138 8
4139 }
4140
4141 #[inline(always)]
4142 fn inline_size(_context: fidl::encoding::Context) -> usize {
4143 16
4144 }
4145 }
4146
4147 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
4148 unsafe fn encode(
4149 self,
4150 encoder: &mut fidl::encoding::Encoder<'_, D>,
4151 offset: usize,
4152 mut depth: fidl::encoding::Depth,
4153 ) -> fidl::Result<()> {
4154 encoder.debug_check_bounds::<Options>(offset);
4155 let max_ordinal: u64 = self.max_ordinal_present();
4157 encoder.write_num(max_ordinal, offset);
4158 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4159 if max_ordinal == 0 {
4161 return Ok(());
4162 }
4163 depth.increment()?;
4164 let envelope_size = 8;
4165 let bytes_len = max_ordinal as usize * envelope_size;
4166 #[allow(unused_variables)]
4167 let offset = encoder.out_of_line_offset(bytes_len);
4168 let mut _prev_end_offset: usize = 0;
4169 if 1 > max_ordinal {
4170 return Ok(());
4171 }
4172
4173 let cur_offset: usize = (1 - 1) * envelope_size;
4176
4177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4179
4180 fidl::encoding::encode_in_envelope_optional::<Initiator, D>(
4185 self.initiator.as_ref().map(<Initiator as fidl::encoding::ValueTypeMarker>::borrow),
4186 encoder,
4187 offset + cur_offset,
4188 depth,
4189 )?;
4190
4191 _prev_end_offset = cur_offset + envelope_size;
4192 if 2 > max_ordinal {
4193 return Ok(());
4194 }
4195
4196 let cur_offset: usize = (2 - 1) * envelope_size;
4199
4200 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4202
4203 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4208 self.allow_attach_to_existing_attempt
4209 .as_ref()
4210 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4211 encoder,
4212 offset + cur_offset,
4213 depth,
4214 )?;
4215
4216 _prev_end_offset = cur_offset + envelope_size;
4217 if 3 > max_ordinal {
4218 return Ok(());
4219 }
4220
4221 let cur_offset: usize = (3 - 1) * envelope_size;
4224
4225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4227
4228 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4233 self.should_write_recovery
4234 .as_ref()
4235 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4236 encoder,
4237 offset + cur_offset,
4238 depth,
4239 )?;
4240
4241 _prev_end_offset = cur_offset + envelope_size;
4242
4243 Ok(())
4244 }
4245 }
4246
4247 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
4248 #[inline(always)]
4249 fn new_empty() -> Self {
4250 Self::default()
4251 }
4252
4253 unsafe fn decode(
4254 &mut self,
4255 decoder: &mut fidl::encoding::Decoder<'_, D>,
4256 offset: usize,
4257 mut depth: fidl::encoding::Depth,
4258 ) -> fidl::Result<()> {
4259 decoder.debug_check_bounds::<Self>(offset);
4260 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4261 None => return Err(fidl::Error::NotNullable),
4262 Some(len) => len,
4263 };
4264 if len == 0 {
4266 return Ok(());
4267 };
4268 depth.increment()?;
4269 let envelope_size = 8;
4270 let bytes_len = len * envelope_size;
4271 let offset = decoder.out_of_line_offset(bytes_len)?;
4272 let mut _next_ordinal_to_read = 0;
4274 let mut next_offset = offset;
4275 let end_offset = offset + bytes_len;
4276 _next_ordinal_to_read += 1;
4277 if next_offset >= end_offset {
4278 return Ok(());
4279 }
4280
4281 while _next_ordinal_to_read < 1 {
4283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4284 _next_ordinal_to_read += 1;
4285 next_offset += envelope_size;
4286 }
4287
4288 let next_out_of_line = decoder.next_out_of_line();
4289 let handles_before = decoder.remaining_handles();
4290 if let Some((inlined, num_bytes, num_handles)) =
4291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4292 {
4293 let member_inline_size =
4294 <Initiator as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4295 if inlined != (member_inline_size <= 4) {
4296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4297 }
4298 let inner_offset;
4299 let mut inner_depth = depth.clone();
4300 if inlined {
4301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4302 inner_offset = next_offset;
4303 } else {
4304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4305 inner_depth.increment()?;
4306 }
4307 let val_ref = self.initiator.get_or_insert_with(|| fidl::new_empty!(Initiator, D));
4308 fidl::decode!(Initiator, D, val_ref, decoder, inner_offset, inner_depth)?;
4309 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4310 {
4311 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4312 }
4313 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4314 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4315 }
4316 }
4317
4318 next_offset += envelope_size;
4319 _next_ordinal_to_read += 1;
4320 if next_offset >= end_offset {
4321 return Ok(());
4322 }
4323
4324 while _next_ordinal_to_read < 2 {
4326 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4327 _next_ordinal_to_read += 1;
4328 next_offset += envelope_size;
4329 }
4330
4331 let next_out_of_line = decoder.next_out_of_line();
4332 let handles_before = decoder.remaining_handles();
4333 if let Some((inlined, num_bytes, num_handles)) =
4334 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4335 {
4336 let member_inline_size =
4337 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4338 if inlined != (member_inline_size <= 4) {
4339 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4340 }
4341 let inner_offset;
4342 let mut inner_depth = depth.clone();
4343 if inlined {
4344 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4345 inner_offset = next_offset;
4346 } else {
4347 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4348 inner_depth.increment()?;
4349 }
4350 let val_ref = self
4351 .allow_attach_to_existing_attempt
4352 .get_or_insert_with(|| fidl::new_empty!(bool, D));
4353 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4355 {
4356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4357 }
4358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4360 }
4361 }
4362
4363 next_offset += envelope_size;
4364 _next_ordinal_to_read += 1;
4365 if next_offset >= end_offset {
4366 return Ok(());
4367 }
4368
4369 while _next_ordinal_to_read < 3 {
4371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4372 _next_ordinal_to_read += 1;
4373 next_offset += envelope_size;
4374 }
4375
4376 let next_out_of_line = decoder.next_out_of_line();
4377 let handles_before = decoder.remaining_handles();
4378 if let Some((inlined, num_bytes, num_handles)) =
4379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4380 {
4381 let member_inline_size =
4382 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4383 if inlined != (member_inline_size <= 4) {
4384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4385 }
4386 let inner_offset;
4387 let mut inner_depth = depth.clone();
4388 if inlined {
4389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4390 inner_offset = next_offset;
4391 } else {
4392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4393 inner_depth.increment()?;
4394 }
4395 let val_ref =
4396 self.should_write_recovery.get_or_insert_with(|| fidl::new_empty!(bool, D));
4397 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4399 {
4400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4401 }
4402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4404 }
4405 }
4406
4407 next_offset += envelope_size;
4408
4409 while next_offset < end_offset {
4411 _next_ordinal_to_read += 1;
4412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4413 next_offset += envelope_size;
4414 }
4415
4416 Ok(())
4417 }
4418 }
4419
4420 impl PrepareData {
4421 #[inline(always)]
4422 fn max_ordinal_present(&self) -> u64 {
4423 0
4424 }
4425 }
4426
4427 impl fidl::encoding::ValueTypeMarker for PrepareData {
4428 type Borrowed<'a> = &'a Self;
4429 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4430 value
4431 }
4432 }
4433
4434 unsafe impl fidl::encoding::TypeMarker for PrepareData {
4435 type Owned = Self;
4436
4437 #[inline(always)]
4438 fn inline_align(_context: fidl::encoding::Context) -> usize {
4439 8
4440 }
4441
4442 #[inline(always)]
4443 fn inline_size(_context: fidl::encoding::Context) -> usize {
4444 16
4445 }
4446 }
4447
4448 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PrepareData, D>
4449 for &PrepareData
4450 {
4451 unsafe fn encode(
4452 self,
4453 encoder: &mut fidl::encoding::Encoder<'_, D>,
4454 offset: usize,
4455 mut depth: fidl::encoding::Depth,
4456 ) -> fidl::Result<()> {
4457 encoder.debug_check_bounds::<PrepareData>(offset);
4458 let max_ordinal: u64 = self.max_ordinal_present();
4460 encoder.write_num(max_ordinal, offset);
4461 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4462 if max_ordinal == 0 {
4464 return Ok(());
4465 }
4466 depth.increment()?;
4467 let envelope_size = 8;
4468 let bytes_len = max_ordinal as usize * envelope_size;
4469 #[allow(unused_variables)]
4470 let offset = encoder.out_of_line_offset(bytes_len);
4471 let mut _prev_end_offset: usize = 0;
4472
4473 Ok(())
4474 }
4475 }
4476
4477 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PrepareData {
4478 #[inline(always)]
4479 fn new_empty() -> Self {
4480 Self::default()
4481 }
4482
4483 unsafe fn decode(
4484 &mut self,
4485 decoder: &mut fidl::encoding::Decoder<'_, D>,
4486 offset: usize,
4487 mut depth: fidl::encoding::Depth,
4488 ) -> fidl::Result<()> {
4489 decoder.debug_check_bounds::<Self>(offset);
4490 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4491 None => return Err(fidl::Error::NotNullable),
4492 Some(len) => len,
4493 };
4494 if len == 0 {
4496 return Ok(());
4497 };
4498 depth.increment()?;
4499 let envelope_size = 8;
4500 let bytes_len = len * envelope_size;
4501 let offset = decoder.out_of_line_offset(bytes_len)?;
4502 let mut _next_ordinal_to_read = 0;
4504 let mut next_offset = offset;
4505 let end_offset = offset + bytes_len;
4506
4507 while next_offset < end_offset {
4509 _next_ordinal_to_read += 1;
4510 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4511 next_offset += envelope_size;
4512 }
4513
4514 Ok(())
4515 }
4516 }
4517
4518 impl RebootData {
4519 #[inline(always)]
4520 fn max_ordinal_present(&self) -> u64 {
4521 if let Some(_) = self.progress {
4522 return 2;
4523 }
4524 if let Some(_) = self.info {
4525 return 1;
4526 }
4527 0
4528 }
4529 }
4530
4531 impl fidl::encoding::ValueTypeMarker for RebootData {
4532 type Borrowed<'a> = &'a Self;
4533 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4534 value
4535 }
4536 }
4537
4538 unsafe impl fidl::encoding::TypeMarker for RebootData {
4539 type Owned = Self;
4540
4541 #[inline(always)]
4542 fn inline_align(_context: fidl::encoding::Context) -> usize {
4543 8
4544 }
4545
4546 #[inline(always)]
4547 fn inline_size(_context: fidl::encoding::Context) -> usize {
4548 16
4549 }
4550 }
4551
4552 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RebootData, D>
4553 for &RebootData
4554 {
4555 unsafe fn encode(
4556 self,
4557 encoder: &mut fidl::encoding::Encoder<'_, D>,
4558 offset: usize,
4559 mut depth: fidl::encoding::Depth,
4560 ) -> fidl::Result<()> {
4561 encoder.debug_check_bounds::<RebootData>(offset);
4562 let max_ordinal: u64 = self.max_ordinal_present();
4564 encoder.write_num(max_ordinal, offset);
4565 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4566 if max_ordinal == 0 {
4568 return Ok(());
4569 }
4570 depth.increment()?;
4571 let envelope_size = 8;
4572 let bytes_len = max_ordinal as usize * envelope_size;
4573 #[allow(unused_variables)]
4574 let offset = encoder.out_of_line_offset(bytes_len);
4575 let mut _prev_end_offset: usize = 0;
4576 if 1 > max_ordinal {
4577 return Ok(());
4578 }
4579
4580 let cur_offset: usize = (1 - 1) * envelope_size;
4583
4584 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4586
4587 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
4592 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
4593 encoder,
4594 offset + cur_offset,
4595 depth,
4596 )?;
4597
4598 _prev_end_offset = cur_offset + envelope_size;
4599 if 2 > max_ordinal {
4600 return Ok(());
4601 }
4602
4603 let cur_offset: usize = (2 - 1) * envelope_size;
4606
4607 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4609
4610 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
4615 self.progress
4616 .as_ref()
4617 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
4618 encoder,
4619 offset + cur_offset,
4620 depth,
4621 )?;
4622
4623 _prev_end_offset = cur_offset + envelope_size;
4624
4625 Ok(())
4626 }
4627 }
4628
4629 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RebootData {
4630 #[inline(always)]
4631 fn new_empty() -> Self {
4632 Self::default()
4633 }
4634
4635 unsafe fn decode(
4636 &mut self,
4637 decoder: &mut fidl::encoding::Decoder<'_, D>,
4638 offset: usize,
4639 mut depth: fidl::encoding::Depth,
4640 ) -> fidl::Result<()> {
4641 decoder.debug_check_bounds::<Self>(offset);
4642 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4643 None => return Err(fidl::Error::NotNullable),
4644 Some(len) => len,
4645 };
4646 if len == 0 {
4648 return Ok(());
4649 };
4650 depth.increment()?;
4651 let envelope_size = 8;
4652 let bytes_len = len * envelope_size;
4653 let offset = decoder.out_of_line_offset(bytes_len)?;
4654 let mut _next_ordinal_to_read = 0;
4656 let mut next_offset = offset;
4657 let end_offset = offset + bytes_len;
4658 _next_ordinal_to_read += 1;
4659 if next_offset >= end_offset {
4660 return Ok(());
4661 }
4662
4663 while _next_ordinal_to_read < 1 {
4665 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4666 _next_ordinal_to_read += 1;
4667 next_offset += envelope_size;
4668 }
4669
4670 let next_out_of_line = decoder.next_out_of_line();
4671 let handles_before = decoder.remaining_handles();
4672 if let Some((inlined, num_bytes, num_handles)) =
4673 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4674 {
4675 let member_inline_size =
4676 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4677 if inlined != (member_inline_size <= 4) {
4678 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4679 }
4680 let inner_offset;
4681 let mut inner_depth = depth.clone();
4682 if inlined {
4683 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4684 inner_offset = next_offset;
4685 } else {
4686 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4687 inner_depth.increment()?;
4688 }
4689 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
4690 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
4691 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4692 {
4693 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4694 }
4695 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4696 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4697 }
4698 }
4699
4700 next_offset += envelope_size;
4701 _next_ordinal_to_read += 1;
4702 if next_offset >= end_offset {
4703 return Ok(());
4704 }
4705
4706 while _next_ordinal_to_read < 2 {
4708 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4709 _next_ordinal_to_read += 1;
4710 next_offset += envelope_size;
4711 }
4712
4713 let next_out_of_line = decoder.next_out_of_line();
4714 let handles_before = decoder.remaining_handles();
4715 if let Some((inlined, num_bytes, num_handles)) =
4716 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4717 {
4718 let member_inline_size =
4719 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
4720 decoder.context,
4721 );
4722 if inlined != (member_inline_size <= 4) {
4723 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4724 }
4725 let inner_offset;
4726 let mut inner_depth = depth.clone();
4727 if inlined {
4728 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4729 inner_offset = next_offset;
4730 } else {
4731 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4732 inner_depth.increment()?;
4733 }
4734 let val_ref =
4735 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
4736 fidl::decode!(
4737 InstallationProgress,
4738 D,
4739 val_ref,
4740 decoder,
4741 inner_offset,
4742 inner_depth
4743 )?;
4744 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4745 {
4746 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4747 }
4748 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4749 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4750 }
4751 }
4752
4753 next_offset += envelope_size;
4754
4755 while next_offset < end_offset {
4757 _next_ordinal_to_read += 1;
4758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4759 next_offset += envelope_size;
4760 }
4761
4762 Ok(())
4763 }
4764 }
4765
4766 impl StageData {
4767 #[inline(always)]
4768 fn max_ordinal_present(&self) -> u64 {
4769 if let Some(_) = self.progress {
4770 return 2;
4771 }
4772 if let Some(_) = self.info {
4773 return 1;
4774 }
4775 0
4776 }
4777 }
4778
4779 impl fidl::encoding::ValueTypeMarker for StageData {
4780 type Borrowed<'a> = &'a Self;
4781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4782 value
4783 }
4784 }
4785
4786 unsafe impl fidl::encoding::TypeMarker for StageData {
4787 type Owned = Self;
4788
4789 #[inline(always)]
4790 fn inline_align(_context: fidl::encoding::Context) -> usize {
4791 8
4792 }
4793
4794 #[inline(always)]
4795 fn inline_size(_context: fidl::encoding::Context) -> usize {
4796 16
4797 }
4798 }
4799
4800 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StageData, D>
4801 for &StageData
4802 {
4803 unsafe fn encode(
4804 self,
4805 encoder: &mut fidl::encoding::Encoder<'_, D>,
4806 offset: usize,
4807 mut depth: fidl::encoding::Depth,
4808 ) -> fidl::Result<()> {
4809 encoder.debug_check_bounds::<StageData>(offset);
4810 let max_ordinal: u64 = self.max_ordinal_present();
4812 encoder.write_num(max_ordinal, offset);
4813 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4814 if max_ordinal == 0 {
4816 return Ok(());
4817 }
4818 depth.increment()?;
4819 let envelope_size = 8;
4820 let bytes_len = max_ordinal as usize * envelope_size;
4821 #[allow(unused_variables)]
4822 let offset = encoder.out_of_line_offset(bytes_len);
4823 let mut _prev_end_offset: usize = 0;
4824 if 1 > max_ordinal {
4825 return Ok(());
4826 }
4827
4828 let cur_offset: usize = (1 - 1) * envelope_size;
4831
4832 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4834
4835 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
4840 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
4841 encoder,
4842 offset + cur_offset,
4843 depth,
4844 )?;
4845
4846 _prev_end_offset = cur_offset + envelope_size;
4847 if 2 > max_ordinal {
4848 return Ok(());
4849 }
4850
4851 let cur_offset: usize = (2 - 1) * envelope_size;
4854
4855 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4857
4858 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
4863 self.progress
4864 .as_ref()
4865 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
4866 encoder,
4867 offset + cur_offset,
4868 depth,
4869 )?;
4870
4871 _prev_end_offset = cur_offset + envelope_size;
4872
4873 Ok(())
4874 }
4875 }
4876
4877 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StageData {
4878 #[inline(always)]
4879 fn new_empty() -> Self {
4880 Self::default()
4881 }
4882
4883 unsafe fn decode(
4884 &mut self,
4885 decoder: &mut fidl::encoding::Decoder<'_, D>,
4886 offset: usize,
4887 mut depth: fidl::encoding::Depth,
4888 ) -> fidl::Result<()> {
4889 decoder.debug_check_bounds::<Self>(offset);
4890 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4891 None => return Err(fidl::Error::NotNullable),
4892 Some(len) => len,
4893 };
4894 if len == 0 {
4896 return Ok(());
4897 };
4898 depth.increment()?;
4899 let envelope_size = 8;
4900 let bytes_len = len * envelope_size;
4901 let offset = decoder.out_of_line_offset(bytes_len)?;
4902 let mut _next_ordinal_to_read = 0;
4904 let mut next_offset = offset;
4905 let end_offset = offset + bytes_len;
4906 _next_ordinal_to_read += 1;
4907 if next_offset >= end_offset {
4908 return Ok(());
4909 }
4910
4911 while _next_ordinal_to_read < 1 {
4913 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4914 _next_ordinal_to_read += 1;
4915 next_offset += envelope_size;
4916 }
4917
4918 let next_out_of_line = decoder.next_out_of_line();
4919 let handles_before = decoder.remaining_handles();
4920 if let Some((inlined, num_bytes, num_handles)) =
4921 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4922 {
4923 let member_inline_size =
4924 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4925 if inlined != (member_inline_size <= 4) {
4926 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4927 }
4928 let inner_offset;
4929 let mut inner_depth = depth.clone();
4930 if inlined {
4931 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4932 inner_offset = next_offset;
4933 } else {
4934 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4935 inner_depth.increment()?;
4936 }
4937 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
4938 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
4939 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4940 {
4941 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4942 }
4943 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4944 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4945 }
4946 }
4947
4948 next_offset += envelope_size;
4949 _next_ordinal_to_read += 1;
4950 if next_offset >= end_offset {
4951 return Ok(());
4952 }
4953
4954 while _next_ordinal_to_read < 2 {
4956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4957 _next_ordinal_to_read += 1;
4958 next_offset += envelope_size;
4959 }
4960
4961 let next_out_of_line = decoder.next_out_of_line();
4962 let handles_before = decoder.remaining_handles();
4963 if let Some((inlined, num_bytes, num_handles)) =
4964 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4965 {
4966 let member_inline_size =
4967 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
4968 decoder.context,
4969 );
4970 if inlined != (member_inline_size <= 4) {
4971 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4972 }
4973 let inner_offset;
4974 let mut inner_depth = depth.clone();
4975 if inlined {
4976 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4977 inner_offset = next_offset;
4978 } else {
4979 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4980 inner_depth.increment()?;
4981 }
4982 let val_ref =
4983 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
4984 fidl::decode!(
4985 InstallationProgress,
4986 D,
4987 val_ref,
4988 decoder,
4989 inner_offset,
4990 inner_depth
4991 )?;
4992 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4993 {
4994 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4995 }
4996 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4997 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4998 }
4999 }
5000
5001 next_offset += envelope_size;
5002
5003 while next_offset < end_offset {
5005 _next_ordinal_to_read += 1;
5006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5007 next_offset += envelope_size;
5008 }
5009
5010 Ok(())
5011 }
5012 }
5013
5014 impl UpdateInfo {
5015 #[inline(always)]
5016 fn max_ordinal_present(&self) -> u64 {
5017 if let Some(_) = self.download_size {
5018 return 1;
5019 }
5020 0
5021 }
5022 }
5023
5024 impl fidl::encoding::ValueTypeMarker for UpdateInfo {
5025 type Borrowed<'a> = &'a Self;
5026 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5027 value
5028 }
5029 }
5030
5031 unsafe impl fidl::encoding::TypeMarker for UpdateInfo {
5032 type Owned = Self;
5033
5034 #[inline(always)]
5035 fn inline_align(_context: fidl::encoding::Context) -> usize {
5036 8
5037 }
5038
5039 #[inline(always)]
5040 fn inline_size(_context: fidl::encoding::Context) -> usize {
5041 16
5042 }
5043 }
5044
5045 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpdateInfo, D>
5046 for &UpdateInfo
5047 {
5048 unsafe fn encode(
5049 self,
5050 encoder: &mut fidl::encoding::Encoder<'_, D>,
5051 offset: usize,
5052 mut depth: fidl::encoding::Depth,
5053 ) -> fidl::Result<()> {
5054 encoder.debug_check_bounds::<UpdateInfo>(offset);
5055 let max_ordinal: u64 = self.max_ordinal_present();
5057 encoder.write_num(max_ordinal, offset);
5058 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5059 if max_ordinal == 0 {
5061 return Ok(());
5062 }
5063 depth.increment()?;
5064 let envelope_size = 8;
5065 let bytes_len = max_ordinal as usize * envelope_size;
5066 #[allow(unused_variables)]
5067 let offset = encoder.out_of_line_offset(bytes_len);
5068 let mut _prev_end_offset: usize = 0;
5069 if 1 > max_ordinal {
5070 return Ok(());
5071 }
5072
5073 let cur_offset: usize = (1 - 1) * envelope_size;
5076
5077 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5079
5080 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5085 self.download_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5086 encoder,
5087 offset + cur_offset,
5088 depth,
5089 )?;
5090
5091 _prev_end_offset = cur_offset + envelope_size;
5092
5093 Ok(())
5094 }
5095 }
5096
5097 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpdateInfo {
5098 #[inline(always)]
5099 fn new_empty() -> Self {
5100 Self::default()
5101 }
5102
5103 unsafe fn decode(
5104 &mut self,
5105 decoder: &mut fidl::encoding::Decoder<'_, D>,
5106 offset: usize,
5107 mut depth: fidl::encoding::Depth,
5108 ) -> fidl::Result<()> {
5109 decoder.debug_check_bounds::<Self>(offset);
5110 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5111 None => return Err(fidl::Error::NotNullable),
5112 Some(len) => len,
5113 };
5114 if len == 0 {
5116 return Ok(());
5117 };
5118 depth.increment()?;
5119 let envelope_size = 8;
5120 let bytes_len = len * envelope_size;
5121 let offset = decoder.out_of_line_offset(bytes_len)?;
5122 let mut _next_ordinal_to_read = 0;
5124 let mut next_offset = offset;
5125 let end_offset = offset + bytes_len;
5126 _next_ordinal_to_read += 1;
5127 if next_offset >= end_offset {
5128 return Ok(());
5129 }
5130
5131 while _next_ordinal_to_read < 1 {
5133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5134 _next_ordinal_to_read += 1;
5135 next_offset += envelope_size;
5136 }
5137
5138 let next_out_of_line = decoder.next_out_of_line();
5139 let handles_before = decoder.remaining_handles();
5140 if let Some((inlined, num_bytes, num_handles)) =
5141 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5142 {
5143 let member_inline_size =
5144 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5145 if inlined != (member_inline_size <= 4) {
5146 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5147 }
5148 let inner_offset;
5149 let mut inner_depth = depth.clone();
5150 if inlined {
5151 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5152 inner_offset = next_offset;
5153 } else {
5154 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5155 inner_depth.increment()?;
5156 }
5157 let val_ref = self.download_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
5158 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5159 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5160 {
5161 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5162 }
5163 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5164 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5165 }
5166 }
5167
5168 next_offset += envelope_size;
5169
5170 while next_offset < end_offset {
5172 _next_ordinal_to_read += 1;
5173 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5174 next_offset += envelope_size;
5175 }
5176
5177 Ok(())
5178 }
5179 }
5180
5181 impl WaitToRebootData {
5182 #[inline(always)]
5183 fn max_ordinal_present(&self) -> u64 {
5184 if let Some(_) = self.progress {
5185 return 2;
5186 }
5187 if let Some(_) = self.info {
5188 return 1;
5189 }
5190 0
5191 }
5192 }
5193
5194 impl fidl::encoding::ValueTypeMarker for WaitToRebootData {
5195 type Borrowed<'a> = &'a Self;
5196 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5197 value
5198 }
5199 }
5200
5201 unsafe impl fidl::encoding::TypeMarker for WaitToRebootData {
5202 type Owned = Self;
5203
5204 #[inline(always)]
5205 fn inline_align(_context: fidl::encoding::Context) -> usize {
5206 8
5207 }
5208
5209 #[inline(always)]
5210 fn inline_size(_context: fidl::encoding::Context) -> usize {
5211 16
5212 }
5213 }
5214
5215 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WaitToRebootData, D>
5216 for &WaitToRebootData
5217 {
5218 unsafe fn encode(
5219 self,
5220 encoder: &mut fidl::encoding::Encoder<'_, D>,
5221 offset: usize,
5222 mut depth: fidl::encoding::Depth,
5223 ) -> fidl::Result<()> {
5224 encoder.debug_check_bounds::<WaitToRebootData>(offset);
5225 let max_ordinal: u64 = self.max_ordinal_present();
5227 encoder.write_num(max_ordinal, offset);
5228 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5229 if max_ordinal == 0 {
5231 return Ok(());
5232 }
5233 depth.increment()?;
5234 let envelope_size = 8;
5235 let bytes_len = max_ordinal as usize * envelope_size;
5236 #[allow(unused_variables)]
5237 let offset = encoder.out_of_line_offset(bytes_len);
5238 let mut _prev_end_offset: usize = 0;
5239 if 1 > max_ordinal {
5240 return Ok(());
5241 }
5242
5243 let cur_offset: usize = (1 - 1) * envelope_size;
5246
5247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5249
5250 fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
5255 self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
5256 encoder,
5257 offset + cur_offset,
5258 depth,
5259 )?;
5260
5261 _prev_end_offset = cur_offset + envelope_size;
5262 if 2 > max_ordinal {
5263 return Ok(());
5264 }
5265
5266 let cur_offset: usize = (2 - 1) * envelope_size;
5269
5270 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5272
5273 fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
5278 self.progress
5279 .as_ref()
5280 .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
5281 encoder,
5282 offset + cur_offset,
5283 depth,
5284 )?;
5285
5286 _prev_end_offset = cur_offset + envelope_size;
5287
5288 Ok(())
5289 }
5290 }
5291
5292 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WaitToRebootData {
5293 #[inline(always)]
5294 fn new_empty() -> Self {
5295 Self::default()
5296 }
5297
5298 unsafe fn decode(
5299 &mut self,
5300 decoder: &mut fidl::encoding::Decoder<'_, D>,
5301 offset: usize,
5302 mut depth: fidl::encoding::Depth,
5303 ) -> fidl::Result<()> {
5304 decoder.debug_check_bounds::<Self>(offset);
5305 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5306 None => return Err(fidl::Error::NotNullable),
5307 Some(len) => len,
5308 };
5309 if len == 0 {
5311 return Ok(());
5312 };
5313 depth.increment()?;
5314 let envelope_size = 8;
5315 let bytes_len = len * envelope_size;
5316 let offset = decoder.out_of_line_offset(bytes_len)?;
5317 let mut _next_ordinal_to_read = 0;
5319 let mut next_offset = offset;
5320 let end_offset = offset + bytes_len;
5321 _next_ordinal_to_read += 1;
5322 if next_offset >= end_offset {
5323 return Ok(());
5324 }
5325
5326 while _next_ordinal_to_read < 1 {
5328 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5329 _next_ordinal_to_read += 1;
5330 next_offset += envelope_size;
5331 }
5332
5333 let next_out_of_line = decoder.next_out_of_line();
5334 let handles_before = decoder.remaining_handles();
5335 if let Some((inlined, num_bytes, num_handles)) =
5336 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5337 {
5338 let member_inline_size =
5339 <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5340 if inlined != (member_inline_size <= 4) {
5341 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5342 }
5343 let inner_offset;
5344 let mut inner_depth = depth.clone();
5345 if inlined {
5346 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5347 inner_offset = next_offset;
5348 } else {
5349 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5350 inner_depth.increment()?;
5351 }
5352 let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
5353 fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5355 {
5356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5357 }
5358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5360 }
5361 }
5362
5363 next_offset += envelope_size;
5364 _next_ordinal_to_read += 1;
5365 if next_offset >= end_offset {
5366 return Ok(());
5367 }
5368
5369 while _next_ordinal_to_read < 2 {
5371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5372 _next_ordinal_to_read += 1;
5373 next_offset += envelope_size;
5374 }
5375
5376 let next_out_of_line = decoder.next_out_of_line();
5377 let handles_before = decoder.remaining_handles();
5378 if let Some((inlined, num_bytes, num_handles)) =
5379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5380 {
5381 let member_inline_size =
5382 <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
5383 decoder.context,
5384 );
5385 if inlined != (member_inline_size <= 4) {
5386 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5387 }
5388 let inner_offset;
5389 let mut inner_depth = depth.clone();
5390 if inlined {
5391 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5392 inner_offset = next_offset;
5393 } else {
5394 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5395 inner_depth.increment()?;
5396 }
5397 let val_ref =
5398 self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
5399 fidl::decode!(
5400 InstallationProgress,
5401 D,
5402 val_ref,
5403 decoder,
5404 inner_offset,
5405 inner_depth
5406 )?;
5407 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5408 {
5409 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5410 }
5411 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5412 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5413 }
5414 }
5415
5416 next_offset += envelope_size;
5417
5418 while next_offset < end_offset {
5420 _next_ordinal_to_read += 1;
5421 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5422 next_offset += envelope_size;
5423 }
5424
5425 Ok(())
5426 }
5427 }
5428
5429 impl fidl::encoding::ValueTypeMarker for State {
5430 type Borrowed<'a> = &'a Self;
5431 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5432 value
5433 }
5434 }
5435
5436 unsafe impl fidl::encoding::TypeMarker for State {
5437 type Owned = Self;
5438
5439 #[inline(always)]
5440 fn inline_align(_context: fidl::encoding::Context) -> usize {
5441 8
5442 }
5443
5444 #[inline(always)]
5445 fn inline_size(_context: fidl::encoding::Context) -> usize {
5446 16
5447 }
5448 }
5449
5450 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<State, D> for &State {
5451 #[inline]
5452 unsafe fn encode(
5453 self,
5454 encoder: &mut fidl::encoding::Encoder<'_, D>,
5455 offset: usize,
5456 _depth: fidl::encoding::Depth,
5457 ) -> fidl::Result<()> {
5458 encoder.debug_check_bounds::<State>(offset);
5459 encoder.write_num::<u64>(self.ordinal(), offset);
5460 match self {
5461 State::Prepare(ref val) => fidl::encoding::encode_in_envelope::<PrepareData, D>(
5462 <PrepareData as fidl::encoding::ValueTypeMarker>::borrow(val),
5463 encoder,
5464 offset + 8,
5465 _depth,
5466 ),
5467 State::Stage(ref val) => fidl::encoding::encode_in_envelope::<StageData, D>(
5468 <StageData as fidl::encoding::ValueTypeMarker>::borrow(val),
5469 encoder,
5470 offset + 8,
5471 _depth,
5472 ),
5473 State::Fetch(ref val) => fidl::encoding::encode_in_envelope::<FetchData, D>(
5474 <FetchData as fidl::encoding::ValueTypeMarker>::borrow(val),
5475 encoder,
5476 offset + 8,
5477 _depth,
5478 ),
5479 State::Commit(ref val) => fidl::encoding::encode_in_envelope::<CommitData, D>(
5480 <CommitData as fidl::encoding::ValueTypeMarker>::borrow(val),
5481 encoder,
5482 offset + 8,
5483 _depth,
5484 ),
5485 State::WaitToReboot(ref val) => {
5486 fidl::encoding::encode_in_envelope::<WaitToRebootData, D>(
5487 <WaitToRebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5488 encoder,
5489 offset + 8,
5490 _depth,
5491 )
5492 }
5493 State::Reboot(ref val) => fidl::encoding::encode_in_envelope::<RebootData, D>(
5494 <RebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5495 encoder,
5496 offset + 8,
5497 _depth,
5498 ),
5499 State::DeferReboot(ref val) => {
5500 fidl::encoding::encode_in_envelope::<DeferRebootData, D>(
5501 <DeferRebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5502 encoder,
5503 offset + 8,
5504 _depth,
5505 )
5506 }
5507 State::Complete(ref val) => fidl::encoding::encode_in_envelope::<CompleteData, D>(
5508 <CompleteData as fidl::encoding::ValueTypeMarker>::borrow(val),
5509 encoder,
5510 offset + 8,
5511 _depth,
5512 ),
5513 State::FailPrepare(ref val) => {
5514 fidl::encoding::encode_in_envelope::<FailPrepareData, D>(
5515 <FailPrepareData as fidl::encoding::ValueTypeMarker>::borrow(val),
5516 encoder,
5517 offset + 8,
5518 _depth,
5519 )
5520 }
5521 State::FailStage(ref val) => {
5522 fidl::encoding::encode_in_envelope::<FailStageData, D>(
5523 <FailStageData as fidl::encoding::ValueTypeMarker>::borrow(val),
5524 encoder,
5525 offset + 8,
5526 _depth,
5527 )
5528 }
5529 State::FailFetch(ref val) => {
5530 fidl::encoding::encode_in_envelope::<FailFetchData, D>(
5531 <FailFetchData as fidl::encoding::ValueTypeMarker>::borrow(val),
5532 encoder,
5533 offset + 8,
5534 _depth,
5535 )
5536 }
5537 State::FailCommit(ref val) => {
5538 fidl::encoding::encode_in_envelope::<FailCommitData, D>(
5539 <FailCommitData as fidl::encoding::ValueTypeMarker>::borrow(val),
5540 encoder,
5541 offset + 8,
5542 _depth,
5543 )
5544 }
5545 State::Canceled(ref val) => fidl::encoding::encode_in_envelope::<CanceledData, D>(
5546 <CanceledData as fidl::encoding::ValueTypeMarker>::borrow(val),
5547 encoder,
5548 offset + 8,
5549 _depth,
5550 ),
5551 }
5552 }
5553 }
5554
5555 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for State {
5556 #[inline(always)]
5557 fn new_empty() -> Self {
5558 Self::Prepare(fidl::new_empty!(PrepareData, D))
5559 }
5560
5561 #[inline]
5562 unsafe fn decode(
5563 &mut self,
5564 decoder: &mut fidl::encoding::Decoder<'_, D>,
5565 offset: usize,
5566 mut depth: fidl::encoding::Depth,
5567 ) -> fidl::Result<()> {
5568 decoder.debug_check_bounds::<Self>(offset);
5569 #[allow(unused_variables)]
5570 let next_out_of_line = decoder.next_out_of_line();
5571 let handles_before = decoder.remaining_handles();
5572 let (ordinal, inlined, num_bytes, num_handles) =
5573 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5574
5575 let member_inline_size = match ordinal {
5576 1 => <PrepareData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5577 2 => <StageData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5578 3 => <FetchData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5579 4 => <CommitData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5580 5 => <WaitToRebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5581 6 => <RebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5582 7 => <DeferRebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5583 8 => <CompleteData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5584 9 => <FailPrepareData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5585 10 => <FailStageData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5586 11 => <FailFetchData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5587 12 => <FailCommitData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5588 13 => <CanceledData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5589 _ => return Err(fidl::Error::UnknownUnionTag),
5590 };
5591
5592 if inlined != (member_inline_size <= 4) {
5593 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5594 }
5595 let _inner_offset;
5596 if inlined {
5597 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5598 _inner_offset = offset + 8;
5599 } else {
5600 depth.increment()?;
5601 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5602 }
5603 match ordinal {
5604 1 => {
5605 #[allow(irrefutable_let_patterns)]
5606 if let State::Prepare(_) = self {
5607 } else {
5609 *self = State::Prepare(fidl::new_empty!(PrepareData, D));
5611 }
5612 #[allow(irrefutable_let_patterns)]
5613 if let State::Prepare(ref mut val) = self {
5614 fidl::decode!(PrepareData, D, val, decoder, _inner_offset, depth)?;
5615 } else {
5616 unreachable!()
5617 }
5618 }
5619 2 => {
5620 #[allow(irrefutable_let_patterns)]
5621 if let State::Stage(_) = self {
5622 } else {
5624 *self = State::Stage(fidl::new_empty!(StageData, D));
5626 }
5627 #[allow(irrefutable_let_patterns)]
5628 if let State::Stage(ref mut val) = self {
5629 fidl::decode!(StageData, D, val, decoder, _inner_offset, depth)?;
5630 } else {
5631 unreachable!()
5632 }
5633 }
5634 3 => {
5635 #[allow(irrefutable_let_patterns)]
5636 if let State::Fetch(_) = self {
5637 } else {
5639 *self = State::Fetch(fidl::new_empty!(FetchData, D));
5641 }
5642 #[allow(irrefutable_let_patterns)]
5643 if let State::Fetch(ref mut val) = self {
5644 fidl::decode!(FetchData, D, val, decoder, _inner_offset, depth)?;
5645 } else {
5646 unreachable!()
5647 }
5648 }
5649 4 => {
5650 #[allow(irrefutable_let_patterns)]
5651 if let State::Commit(_) = self {
5652 } else {
5654 *self = State::Commit(fidl::new_empty!(CommitData, D));
5656 }
5657 #[allow(irrefutable_let_patterns)]
5658 if let State::Commit(ref mut val) = self {
5659 fidl::decode!(CommitData, D, val, decoder, _inner_offset, depth)?;
5660 } else {
5661 unreachable!()
5662 }
5663 }
5664 5 => {
5665 #[allow(irrefutable_let_patterns)]
5666 if let State::WaitToReboot(_) = self {
5667 } else {
5669 *self = State::WaitToReboot(fidl::new_empty!(WaitToRebootData, D));
5671 }
5672 #[allow(irrefutable_let_patterns)]
5673 if let State::WaitToReboot(ref mut val) = self {
5674 fidl::decode!(WaitToRebootData, D, val, decoder, _inner_offset, depth)?;
5675 } else {
5676 unreachable!()
5677 }
5678 }
5679 6 => {
5680 #[allow(irrefutable_let_patterns)]
5681 if let State::Reboot(_) = self {
5682 } else {
5684 *self = State::Reboot(fidl::new_empty!(RebootData, D));
5686 }
5687 #[allow(irrefutable_let_patterns)]
5688 if let State::Reboot(ref mut val) = self {
5689 fidl::decode!(RebootData, D, val, decoder, _inner_offset, depth)?;
5690 } else {
5691 unreachable!()
5692 }
5693 }
5694 7 => {
5695 #[allow(irrefutable_let_patterns)]
5696 if let State::DeferReboot(_) = self {
5697 } else {
5699 *self = State::DeferReboot(fidl::new_empty!(DeferRebootData, D));
5701 }
5702 #[allow(irrefutable_let_patterns)]
5703 if let State::DeferReboot(ref mut val) = self {
5704 fidl::decode!(DeferRebootData, D, val, decoder, _inner_offset, depth)?;
5705 } else {
5706 unreachable!()
5707 }
5708 }
5709 8 => {
5710 #[allow(irrefutable_let_patterns)]
5711 if let State::Complete(_) = self {
5712 } else {
5714 *self = State::Complete(fidl::new_empty!(CompleteData, D));
5716 }
5717 #[allow(irrefutable_let_patterns)]
5718 if let State::Complete(ref mut val) = self {
5719 fidl::decode!(CompleteData, D, val, decoder, _inner_offset, depth)?;
5720 } else {
5721 unreachable!()
5722 }
5723 }
5724 9 => {
5725 #[allow(irrefutable_let_patterns)]
5726 if let State::FailPrepare(_) = self {
5727 } else {
5729 *self = State::FailPrepare(fidl::new_empty!(FailPrepareData, D));
5731 }
5732 #[allow(irrefutable_let_patterns)]
5733 if let State::FailPrepare(ref mut val) = self {
5734 fidl::decode!(FailPrepareData, D, val, decoder, _inner_offset, depth)?;
5735 } else {
5736 unreachable!()
5737 }
5738 }
5739 10 => {
5740 #[allow(irrefutable_let_patterns)]
5741 if let State::FailStage(_) = self {
5742 } else {
5744 *self = State::FailStage(fidl::new_empty!(FailStageData, D));
5746 }
5747 #[allow(irrefutable_let_patterns)]
5748 if let State::FailStage(ref mut val) = self {
5749 fidl::decode!(FailStageData, D, val, decoder, _inner_offset, depth)?;
5750 } else {
5751 unreachable!()
5752 }
5753 }
5754 11 => {
5755 #[allow(irrefutable_let_patterns)]
5756 if let State::FailFetch(_) = self {
5757 } else {
5759 *self = State::FailFetch(fidl::new_empty!(FailFetchData, D));
5761 }
5762 #[allow(irrefutable_let_patterns)]
5763 if let State::FailFetch(ref mut val) = self {
5764 fidl::decode!(FailFetchData, D, val, decoder, _inner_offset, depth)?;
5765 } else {
5766 unreachable!()
5767 }
5768 }
5769 12 => {
5770 #[allow(irrefutable_let_patterns)]
5771 if let State::FailCommit(_) = self {
5772 } else {
5774 *self = State::FailCommit(fidl::new_empty!(FailCommitData, D));
5776 }
5777 #[allow(irrefutable_let_patterns)]
5778 if let State::FailCommit(ref mut val) = self {
5779 fidl::decode!(FailCommitData, D, val, decoder, _inner_offset, depth)?;
5780 } else {
5781 unreachable!()
5782 }
5783 }
5784 13 => {
5785 #[allow(irrefutable_let_patterns)]
5786 if let State::Canceled(_) = self {
5787 } else {
5789 *self = State::Canceled(fidl::new_empty!(CanceledData, D));
5791 }
5792 #[allow(irrefutable_let_patterns)]
5793 if let State::Canceled(ref mut val) = self {
5794 fidl::decode!(CanceledData, D, val, decoder, _inner_offset, depth)?;
5795 } else {
5796 unreachable!()
5797 }
5798 }
5799 ordinal => panic!("unexpected ordinal {:?}", ordinal),
5800 }
5801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5802 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5803 }
5804 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5805 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5806 }
5807 Ok(())
5808 }
5809 }
5810}