fidl_fuchsia_virtualization__common/
fidl_fuchsia_virtualization__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// VM to VM communication is not supported, so all guests will be assigned this default guest CID.
12pub const DEFAULT_GUEST_CID: u32 = 3;
13
14/// `HOST_CID` is the reserved context ID (CID) of the host.
15pub const HOST_CID: u32 = 2;
16
17pub const MAX_BLOCK_DEVICES: u8 = 32;
18
19pub const MAX_BLOCK_DEVICE_ID: u8 = 20;
20
21pub const MAX_MEMORY: u8 = 32;
22
23pub const MAX_NET_DEVICES: u8 = 32;
24
25#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
26#[repr(u32)]
27pub enum BlockMode {
28    /// Reads and writes are allowed.
29    ReadWrite = 0,
30    /// Only reads are allowed.
31    ReadOnly = 1,
32    /// Writes are allowed, but are stored in memory, not to disk.
33    VolatileWrite = 2,
34}
35
36impl BlockMode {
37    #[inline]
38    pub fn from_primitive(prim: u32) -> Option<Self> {
39        match prim {
40            0 => Some(Self::ReadWrite),
41            1 => Some(Self::ReadOnly),
42            2 => Some(Self::VolatileWrite),
43            _ => None,
44        }
45    }
46
47    #[inline]
48    pub const fn into_primitive(self) -> u32 {
49        self as u32
50    }
51}
52
53/// The status of the Linux container.
54#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
55#[repr(u32)]
56pub enum ContainerStatus {
57    Transient = 1,
58    LaunchingGuest = 2,
59    StartingVm = 3,
60    Downloading = 4,
61    Extracting = 5,
62    Starting = 6,
63    Ready = 7,
64    Failed = 8,
65}
66
67impl ContainerStatus {
68    #[inline]
69    pub fn from_primitive(prim: u32) -> Option<Self> {
70        match prim {
71            1 => Some(Self::Transient),
72            2 => Some(Self::LaunchingGuest),
73            3 => Some(Self::StartingVm),
74            4 => Some(Self::Downloading),
75            5 => Some(Self::Extracting),
76            6 => Some(Self::Starting),
77            7 => Some(Self::Ready),
78            8 => Some(Self::Failed),
79            _ => None,
80        }
81    }
82
83    #[inline]
84    pub const fn into_primitive(self) -> u32 {
85        self as u32
86    }
87}
88
89#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
90#[repr(u32)]
91pub enum GuestError {
92    /// Catch all VMM error.
93    InternalError = 1,
94    /// A device endpoint was requested via the guest client API, but the device isn't enabled.
95    DeviceNotPresent = 2,
96    /// The config failed VMM validation for reasons such as a missing required field.
97    BadConfig = 3,
98    /// The VMM failed to initialize the guest object, usually due to capability routing issues
99    /// or memory layout problems.
100    GuestInitializationFailure = 4,
101    /// The VMM failed to initialize a device.
102    DeviceInitializationFailure = 5,
103    /// The VMM failed to start a device, usually because the device component returned a failure.
104    DeviceStartFailure = 6,
105    /// Two or more devices have attempted to register overlapping memory ranges.
106    DeviceMemoryOverlap = 7,
107    /// Failed to connect to a required service. Check the routing in the manifest.
108    FailedServiceConnect = 8,
109    /// Failed to add a public service.
110    DuplicatePublicServices = 9,
111    /// General error when loading the guest kernel.
112    KernelLoadFailure = 10,
113    /// Error when starting a VCPU.
114    VcpuStartFailure = 11,
115    /// A VCPU encountered a fatal error while running.
116    VcpuRuntimeFailure = 12,
117    /// The VMM was asked to run before it was created.
118    NotCreated = 13,
119    /// A VMM is already running. The VMM must be stopped and a new VMM must be created before it
120    /// can be run again.
121    AlreadyRunning = 14,
122    /// A running VMM was forced to stop by the VMM controller.
123    ControllerForcedHalt = 15,
124}
125
126impl GuestError {
127    #[inline]
128    pub fn from_primitive(prim: u32) -> Option<Self> {
129        match prim {
130            1 => Some(Self::InternalError),
131            2 => Some(Self::DeviceNotPresent),
132            3 => Some(Self::BadConfig),
133            4 => Some(Self::GuestInitializationFailure),
134            5 => Some(Self::DeviceInitializationFailure),
135            6 => Some(Self::DeviceStartFailure),
136            7 => Some(Self::DeviceMemoryOverlap),
137            8 => Some(Self::FailedServiceConnect),
138            9 => Some(Self::DuplicatePublicServices),
139            10 => Some(Self::KernelLoadFailure),
140            11 => Some(Self::VcpuStartFailure),
141            12 => Some(Self::VcpuRuntimeFailure),
142            13 => Some(Self::NotCreated),
143            14 => Some(Self::AlreadyRunning),
144            15 => Some(Self::ControllerForcedHalt),
145            _ => None,
146        }
147    }
148
149    #[inline]
150    pub const fn into_primitive(self) -> u32 {
151        self as u32
152    }
153}
154
155#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
156#[repr(u32)]
157pub enum GuestManagerError {
158    /// The guest manager failed to parse the configuration from the guest package, or it was
159    /// otherwise invalid.
160    BadConfig = 1,
161    /// The guest is already running. Stop the guest before attempting to launch again.
162    AlreadyRunning = 2,
163    /// Attempted to connect to a non-running guest.
164    NotRunning = 3,
165    /// Failed to start the guest. See VMM component logs for a more detailed reason.
166    StartFailure = 4,
167    /// The guest required allocating some persistant storage but was unable to
168    /// do so.
169    NoStorage = 5,
170}
171
172impl GuestManagerError {
173    #[inline]
174    pub fn from_primitive(prim: u32) -> Option<Self> {
175        match prim {
176            1 => Some(Self::BadConfig),
177            2 => Some(Self::AlreadyRunning),
178            3 => Some(Self::NotRunning),
179            4 => Some(Self::StartFailure),
180            5 => Some(Self::NoStorage),
181            _ => None,
182        }
183    }
184
185    #[inline]
186    pub const fn into_primitive(self) -> u32 {
187        self as u32
188    }
189}
190
191#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
192#[repr(u32)]
193pub enum GuestStatus {
194    /// Initial state when the guest manager is created but before the guest has ever been run.
195    NotStarted = 1,
196    /// A client has instructed the guest manager to begin launching the guest.
197    Starting = 2,
198    /// The guest's dispatch loops are running. This is the expected steady state.
199    Running = 3,
200    /// A client has instructed the guest manager to begin stopping the guest. If a non-zero
201    /// has been provided, the guest manager may attempt to gracefully shutdown the guest.
202    Stopping = 4,
203    /// The guest is no longer running. A stop reason may be present if the guest stopped due to
204    /// an error.
205    Stopped = 5,
206    /// The VMM component terminated unexpectedly. Attempting to launch the guest again will
207    /// restart the component.
208    VmmUnexpectedTermination = 6,
209}
210
211impl GuestStatus {
212    #[inline]
213    pub fn from_primitive(prim: u32) -> Option<Self> {
214        match prim {
215            1 => Some(Self::NotStarted),
216            2 => Some(Self::Starting),
217            3 => Some(Self::Running),
218            4 => Some(Self::Stopping),
219            5 => Some(Self::Stopped),
220            6 => Some(Self::VmmUnexpectedTermination),
221            _ => None,
222        }
223    }
224
225    #[inline]
226    pub const fn into_primitive(self) -> u32 {
227        self as u32
228    }
229}
230
231/// Type of kernel used by a guest.
232#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
233#[repr(u32)]
234pub enum KernelType {
235    Zircon = 0,
236    Linux = 1,
237}
238
239impl KernelType {
240    #[inline]
241    pub fn from_primitive(prim: u32) -> Option<Self> {
242        match prim {
243            0 => Some(Self::Zircon),
244            1 => Some(Self::Linux),
245            _ => None,
246        }
247    }
248
249    #[inline]
250    pub const fn into_primitive(self) -> u32 {
251        self as u32
252    }
253}
254
255#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
256#[repr(C)]
257pub struct BalloonControllerGetBalloonSizeResponse {
258    pub current_num_pages: u32,
259    pub requested_num_pages: u32,
260}
261
262impl fidl::Persistable for BalloonControllerGetBalloonSizeResponse {}
263
264#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
265pub struct BalloonControllerGetMemStatsResponse {
266    pub status: i32,
267    pub mem_stats: Option<Vec<MemStat>>,
268}
269
270impl fidl::Persistable for BalloonControllerGetMemStatsResponse {}
271
272#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
273#[repr(C)]
274pub struct BalloonControllerRequestNumPagesRequest {
275    pub requested_num_pages: u32,
276}
277
278impl fidl::Persistable for BalloonControllerRequestNumPagesRequest {}
279
280#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
281#[repr(C)]
282pub struct HostVsockAcceptorAcceptRequest {
283    pub src_cid: u32,
284    pub src_port: u32,
285    pub port: u32,
286}
287
288impl fidl::Persistable for HostVsockAcceptorAcceptRequest {}
289
290#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
291#[repr(C)]
292pub struct HostVsockEndpointConnectRequest {
293    pub guest_port: u32,
294}
295
296impl fidl::Persistable for HostVsockEndpointConnectRequest {}
297
298#[derive(Clone, Debug, PartialEq)]
299pub struct LinuxManagerOnGuestInfoChangedRequest {
300    pub label: String,
301    pub info: LinuxGuestInfo,
302}
303
304impl fidl::Persistable for LinuxManagerOnGuestInfoChangedRequest {}
305
306#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
307pub struct LinuxManagerStartAndGetLinuxGuestInfoRequest {
308    pub label: String,
309}
310
311impl fidl::Persistable for LinuxManagerStartAndGetLinuxGuestInfoRequest {}
312
313#[derive(Clone, Debug, PartialEq)]
314pub struct LinuxManagerStartAndGetLinuxGuestInfoResponse {
315    pub info: LinuxGuestInfo,
316}
317
318impl fidl::Persistable for LinuxManagerStartAndGetLinuxGuestInfoResponse {}
319
320/// Properties describing a virtio_magma device.
321#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
322#[repr(C)]
323pub struct MagmaDevice {
324    /// The amount of guest-physical address space to allocate for virtio_magma
325    /// buffers.
326    ///
327    /// Default to a 16GiB allocation.
328    pub memory: u64,
329}
330
331impl fidl::Persistable for MagmaDevice {}
332
333#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
334#[repr(C)]
335pub struct MemControllerGetMemSizeResponse {
336    pub block_size: u64,
337    pub region_size: u64,
338    pub usable_region_size: u64,
339    pub plugged_size: u64,
340    pub requested_size: u64,
341}
342
343impl fidl::Persistable for MemControllerGetMemSizeResponse {}
344
345#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
346#[repr(C)]
347pub struct MemControllerRequestSizeRequest {
348    pub requested_size: u64,
349}
350
351impl fidl::Persistable for MemControllerRequestSizeRequest {}
352
353/// Contains a memory statistic for the balloon device.
354#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
355#[repr(C)]
356pub struct MemStat {
357    pub tag: u16,
358    pub val: u64,
359}
360
361impl fidl::Persistable for MemStat {}
362
363/// Properites describing a network device.
364#[derive(Clone, Debug, PartialEq)]
365pub struct NetSpec {
366    /// MAC address for the network device.
367    pub mac_address: fidl_fuchsia_net__common::MacAddress,
368    /// Whether to bridge the network device with the host network device.
369    pub enable_bridge: bool,
370}
371
372impl fidl::Persistable for NetSpec {}
373
374/// An informational only subset of the GuestConfig. If adding new non-handle entries to the
375/// GuestConfig, consider also adding them here.
376#[derive(Clone, Debug, Default, PartialEq)]
377pub struct GuestDescriptor {
378    /// Number of guest VCPUs.
379    pub num_cpus: Option<u8>,
380    /// Guest memory in bytes.
381    pub guest_memory: Option<u64>,
382    /// Whether the guest was started with the given virtual device.
383    pub wayland: Option<bool>,
384    pub magma: Option<bool>,
385    pub balloon: Option<bool>,
386    pub console: Option<bool>,
387    pub gpu: Option<bool>,
388    pub rng: Option<bool>,
389    pub vsock: Option<bool>,
390    pub sound: Option<bool>,
391    /// The configs for each net device the guest was started with. If empty, there is no
392    /// virtual net device (and the guest will have no networking).
393    pub networks: Option<Vec<NetSpec>>,
394    pub mem: Option<bool>,
395    #[doc(hidden)]
396    pub __source_breaking: fidl::marker::SourceBreaking,
397}
398
399impl fidl::Persistable for GuestDescriptor {}
400
401#[derive(Clone, Debug, Default, PartialEq)]
402pub struct GuestInfo {
403    /// The current state of the guest.
404    pub guest_status: Option<GuestStatus>,
405    /// Current uptime of the guest.
406    pub uptime: Option<i64>,
407    /// A subset of the config used to start the guest.
408    pub guest_descriptor: Option<GuestDescriptor>,
409    /// Contains the last value reported to the guest manager if stopped due to an error.
410    pub stop_error: Option<GuestError>,
411    /// Possible problems with a running guest flagged by the guest manager. These are not fatal
412    /// errors, and should be actionable by a user.
413    ///
414    /// Note that these strings are for diagnostic purposes only. Consumers should not take any
415    /// action based on specific strings as they are subject to change without warning.
416    pub detected_problems: Option<Vec<String>>,
417    #[doc(hidden)]
418    pub __source_breaking: fidl::marker::SourceBreaking,
419}
420
421impl fidl::Persistable for GuestInfo {}
422
423/// Linux guest information.
424#[derive(Clone, Debug, Default, PartialEq)]
425pub struct LinuxGuestInfo {
426    /// Linux guest CID.
427    pub cid: Option<u32>,
428    /// The current container status.
429    pub container_status: Option<ContainerStatus>,
430    /// Container download in percentage. Download percent is only
431    /// available if container status is DOWNLOADING.
432    pub download_percent: Option<i32>,
433    /// The reason for failure if the container could not be created,
434    /// set if container status is FAILED.
435    pub failure_reason: Option<String>,
436    #[doc(hidden)]
437    pub __source_breaking: fidl::marker::SourceBreaking,
438}
439
440impl fidl::Persistable for LinuxGuestInfo {}
441
442mod internal {
443    use super::*;
444    unsafe impl fidl::encoding::TypeMarker for BlockMode {
445        type Owned = Self;
446
447        #[inline(always)]
448        fn inline_align(_context: fidl::encoding::Context) -> usize {
449            std::mem::align_of::<u32>()
450        }
451
452        #[inline(always)]
453        fn inline_size(_context: fidl::encoding::Context) -> usize {
454            std::mem::size_of::<u32>()
455        }
456
457        #[inline(always)]
458        fn encode_is_copy() -> bool {
459            true
460        }
461
462        #[inline(always)]
463        fn decode_is_copy() -> bool {
464            false
465        }
466    }
467
468    impl fidl::encoding::ValueTypeMarker for BlockMode {
469        type Borrowed<'a> = Self;
470        #[inline(always)]
471        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
472            *value
473        }
474    }
475
476    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BlockMode {
477        #[inline]
478        unsafe fn encode(
479            self,
480            encoder: &mut fidl::encoding::Encoder<'_, D>,
481            offset: usize,
482            _depth: fidl::encoding::Depth,
483        ) -> fidl::Result<()> {
484            encoder.debug_check_bounds::<Self>(offset);
485            encoder.write_num(self.into_primitive(), offset);
486            Ok(())
487        }
488    }
489
490    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockMode {
491        #[inline(always)]
492        fn new_empty() -> Self {
493            Self::ReadWrite
494        }
495
496        #[inline]
497        unsafe fn decode(
498            &mut self,
499            decoder: &mut fidl::encoding::Decoder<'_, D>,
500            offset: usize,
501            _depth: fidl::encoding::Depth,
502        ) -> fidl::Result<()> {
503            decoder.debug_check_bounds::<Self>(offset);
504            let prim = decoder.read_num::<u32>(offset);
505
506            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
507            Ok(())
508        }
509    }
510    unsafe impl fidl::encoding::TypeMarker for ContainerStatus {
511        type Owned = Self;
512
513        #[inline(always)]
514        fn inline_align(_context: fidl::encoding::Context) -> usize {
515            std::mem::align_of::<u32>()
516        }
517
518        #[inline(always)]
519        fn inline_size(_context: fidl::encoding::Context) -> usize {
520            std::mem::size_of::<u32>()
521        }
522
523        #[inline(always)]
524        fn encode_is_copy() -> bool {
525            true
526        }
527
528        #[inline(always)]
529        fn decode_is_copy() -> bool {
530            false
531        }
532    }
533
534    impl fidl::encoding::ValueTypeMarker for ContainerStatus {
535        type Borrowed<'a> = Self;
536        #[inline(always)]
537        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
538            *value
539        }
540    }
541
542    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
543        for ContainerStatus
544    {
545        #[inline]
546        unsafe fn encode(
547            self,
548            encoder: &mut fidl::encoding::Encoder<'_, D>,
549            offset: usize,
550            _depth: fidl::encoding::Depth,
551        ) -> fidl::Result<()> {
552            encoder.debug_check_bounds::<Self>(offset);
553            encoder.write_num(self.into_primitive(), offset);
554            Ok(())
555        }
556    }
557
558    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContainerStatus {
559        #[inline(always)]
560        fn new_empty() -> Self {
561            Self::Transient
562        }
563
564        #[inline]
565        unsafe fn decode(
566            &mut self,
567            decoder: &mut fidl::encoding::Decoder<'_, D>,
568            offset: usize,
569            _depth: fidl::encoding::Depth,
570        ) -> fidl::Result<()> {
571            decoder.debug_check_bounds::<Self>(offset);
572            let prim = decoder.read_num::<u32>(offset);
573
574            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
575            Ok(())
576        }
577    }
578    unsafe impl fidl::encoding::TypeMarker for GuestError {
579        type Owned = Self;
580
581        #[inline(always)]
582        fn inline_align(_context: fidl::encoding::Context) -> usize {
583            std::mem::align_of::<u32>()
584        }
585
586        #[inline(always)]
587        fn inline_size(_context: fidl::encoding::Context) -> usize {
588            std::mem::size_of::<u32>()
589        }
590
591        #[inline(always)]
592        fn encode_is_copy() -> bool {
593            true
594        }
595
596        #[inline(always)]
597        fn decode_is_copy() -> bool {
598            false
599        }
600    }
601
602    impl fidl::encoding::ValueTypeMarker for GuestError {
603        type Borrowed<'a> = Self;
604        #[inline(always)]
605        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
606            *value
607        }
608    }
609
610    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GuestError {
611        #[inline]
612        unsafe fn encode(
613            self,
614            encoder: &mut fidl::encoding::Encoder<'_, D>,
615            offset: usize,
616            _depth: fidl::encoding::Depth,
617        ) -> fidl::Result<()> {
618            encoder.debug_check_bounds::<Self>(offset);
619            encoder.write_num(self.into_primitive(), offset);
620            Ok(())
621        }
622    }
623
624    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GuestError {
625        #[inline(always)]
626        fn new_empty() -> Self {
627            Self::InternalError
628        }
629
630        #[inline]
631        unsafe fn decode(
632            &mut self,
633            decoder: &mut fidl::encoding::Decoder<'_, D>,
634            offset: usize,
635            _depth: fidl::encoding::Depth,
636        ) -> fidl::Result<()> {
637            decoder.debug_check_bounds::<Self>(offset);
638            let prim = decoder.read_num::<u32>(offset);
639
640            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
641            Ok(())
642        }
643    }
644    unsafe impl fidl::encoding::TypeMarker for GuestManagerError {
645        type Owned = Self;
646
647        #[inline(always)]
648        fn inline_align(_context: fidl::encoding::Context) -> usize {
649            std::mem::align_of::<u32>()
650        }
651
652        #[inline(always)]
653        fn inline_size(_context: fidl::encoding::Context) -> usize {
654            std::mem::size_of::<u32>()
655        }
656
657        #[inline(always)]
658        fn encode_is_copy() -> bool {
659            true
660        }
661
662        #[inline(always)]
663        fn decode_is_copy() -> bool {
664            false
665        }
666    }
667
668    impl fidl::encoding::ValueTypeMarker for GuestManagerError {
669        type Borrowed<'a> = Self;
670        #[inline(always)]
671        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
672            *value
673        }
674    }
675
676    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
677        for GuestManagerError
678    {
679        #[inline]
680        unsafe fn encode(
681            self,
682            encoder: &mut fidl::encoding::Encoder<'_, D>,
683            offset: usize,
684            _depth: fidl::encoding::Depth,
685        ) -> fidl::Result<()> {
686            encoder.debug_check_bounds::<Self>(offset);
687            encoder.write_num(self.into_primitive(), offset);
688            Ok(())
689        }
690    }
691
692    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GuestManagerError {
693        #[inline(always)]
694        fn new_empty() -> Self {
695            Self::BadConfig
696        }
697
698        #[inline]
699        unsafe fn decode(
700            &mut self,
701            decoder: &mut fidl::encoding::Decoder<'_, D>,
702            offset: usize,
703            _depth: fidl::encoding::Depth,
704        ) -> fidl::Result<()> {
705            decoder.debug_check_bounds::<Self>(offset);
706            let prim = decoder.read_num::<u32>(offset);
707
708            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
709            Ok(())
710        }
711    }
712    unsafe impl fidl::encoding::TypeMarker for GuestStatus {
713        type Owned = Self;
714
715        #[inline(always)]
716        fn inline_align(_context: fidl::encoding::Context) -> usize {
717            std::mem::align_of::<u32>()
718        }
719
720        #[inline(always)]
721        fn inline_size(_context: fidl::encoding::Context) -> usize {
722            std::mem::size_of::<u32>()
723        }
724
725        #[inline(always)]
726        fn encode_is_copy() -> bool {
727            true
728        }
729
730        #[inline(always)]
731        fn decode_is_copy() -> bool {
732            false
733        }
734    }
735
736    impl fidl::encoding::ValueTypeMarker for GuestStatus {
737        type Borrowed<'a> = Self;
738        #[inline(always)]
739        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
740            *value
741        }
742    }
743
744    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GuestStatus {
745        #[inline]
746        unsafe fn encode(
747            self,
748            encoder: &mut fidl::encoding::Encoder<'_, D>,
749            offset: usize,
750            _depth: fidl::encoding::Depth,
751        ) -> fidl::Result<()> {
752            encoder.debug_check_bounds::<Self>(offset);
753            encoder.write_num(self.into_primitive(), offset);
754            Ok(())
755        }
756    }
757
758    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GuestStatus {
759        #[inline(always)]
760        fn new_empty() -> Self {
761            Self::NotStarted
762        }
763
764        #[inline]
765        unsafe fn decode(
766            &mut self,
767            decoder: &mut fidl::encoding::Decoder<'_, D>,
768            offset: usize,
769            _depth: fidl::encoding::Depth,
770        ) -> fidl::Result<()> {
771            decoder.debug_check_bounds::<Self>(offset);
772            let prim = decoder.read_num::<u32>(offset);
773
774            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
775            Ok(())
776        }
777    }
778    unsafe impl fidl::encoding::TypeMarker for KernelType {
779        type Owned = Self;
780
781        #[inline(always)]
782        fn inline_align(_context: fidl::encoding::Context) -> usize {
783            std::mem::align_of::<u32>()
784        }
785
786        #[inline(always)]
787        fn inline_size(_context: fidl::encoding::Context) -> usize {
788            std::mem::size_of::<u32>()
789        }
790
791        #[inline(always)]
792        fn encode_is_copy() -> bool {
793            true
794        }
795
796        #[inline(always)]
797        fn decode_is_copy() -> bool {
798            false
799        }
800    }
801
802    impl fidl::encoding::ValueTypeMarker for KernelType {
803        type Borrowed<'a> = Self;
804        #[inline(always)]
805        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
806            *value
807        }
808    }
809
810    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for KernelType {
811        #[inline]
812        unsafe fn encode(
813            self,
814            encoder: &mut fidl::encoding::Encoder<'_, D>,
815            offset: usize,
816            _depth: fidl::encoding::Depth,
817        ) -> fidl::Result<()> {
818            encoder.debug_check_bounds::<Self>(offset);
819            encoder.write_num(self.into_primitive(), offset);
820            Ok(())
821        }
822    }
823
824    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for KernelType {
825        #[inline(always)]
826        fn new_empty() -> Self {
827            Self::Zircon
828        }
829
830        #[inline]
831        unsafe fn decode(
832            &mut self,
833            decoder: &mut fidl::encoding::Decoder<'_, D>,
834            offset: usize,
835            _depth: fidl::encoding::Depth,
836        ) -> fidl::Result<()> {
837            decoder.debug_check_bounds::<Self>(offset);
838            let prim = decoder.read_num::<u32>(offset);
839
840            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
841            Ok(())
842        }
843    }
844
845    impl fidl::encoding::ValueTypeMarker for BalloonControllerGetBalloonSizeResponse {
846        type Borrowed<'a> = &'a Self;
847        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
848            value
849        }
850    }
851
852    unsafe impl fidl::encoding::TypeMarker for BalloonControllerGetBalloonSizeResponse {
853        type Owned = Self;
854
855        #[inline(always)]
856        fn inline_align(_context: fidl::encoding::Context) -> usize {
857            4
858        }
859
860        #[inline(always)]
861        fn inline_size(_context: fidl::encoding::Context) -> usize {
862            8
863        }
864        #[inline(always)]
865        fn encode_is_copy() -> bool {
866            true
867        }
868
869        #[inline(always)]
870        fn decode_is_copy() -> bool {
871            true
872        }
873    }
874
875    unsafe impl<D: fidl::encoding::ResourceDialect>
876        fidl::encoding::Encode<BalloonControllerGetBalloonSizeResponse, D>
877        for &BalloonControllerGetBalloonSizeResponse
878    {
879        #[inline]
880        unsafe fn encode(
881            self,
882            encoder: &mut fidl::encoding::Encoder<'_, D>,
883            offset: usize,
884            _depth: fidl::encoding::Depth,
885        ) -> fidl::Result<()> {
886            encoder.debug_check_bounds::<BalloonControllerGetBalloonSizeResponse>(offset);
887            unsafe {
888                // Copy the object into the buffer.
889                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
890                (buf_ptr as *mut BalloonControllerGetBalloonSizeResponse).write_unaligned(
891                    (self as *const BalloonControllerGetBalloonSizeResponse).read(),
892                );
893                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
894                // done second because the memcpy will write garbage to these bytes.
895            }
896            Ok(())
897        }
898    }
899    unsafe impl<
900            D: fidl::encoding::ResourceDialect,
901            T0: fidl::encoding::Encode<u32, D>,
902            T1: fidl::encoding::Encode<u32, D>,
903        > fidl::encoding::Encode<BalloonControllerGetBalloonSizeResponse, D> for (T0, T1)
904    {
905        #[inline]
906        unsafe fn encode(
907            self,
908            encoder: &mut fidl::encoding::Encoder<'_, D>,
909            offset: usize,
910            depth: fidl::encoding::Depth,
911        ) -> fidl::Result<()> {
912            encoder.debug_check_bounds::<BalloonControllerGetBalloonSizeResponse>(offset);
913            // Zero out padding regions. There's no need to apply masks
914            // because the unmasked parts will be overwritten by fields.
915            // Write the fields.
916            self.0.encode(encoder, offset + 0, depth)?;
917            self.1.encode(encoder, offset + 4, depth)?;
918            Ok(())
919        }
920    }
921
922    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
923        for BalloonControllerGetBalloonSizeResponse
924    {
925        #[inline(always)]
926        fn new_empty() -> Self {
927            Self {
928                current_num_pages: fidl::new_empty!(u32, D),
929                requested_num_pages: fidl::new_empty!(u32, D),
930            }
931        }
932
933        #[inline]
934        unsafe fn decode(
935            &mut self,
936            decoder: &mut fidl::encoding::Decoder<'_, D>,
937            offset: usize,
938            _depth: fidl::encoding::Depth,
939        ) -> fidl::Result<()> {
940            decoder.debug_check_bounds::<Self>(offset);
941            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
942            // Verify that padding bytes are zero.
943            // Copy from the buffer into the object.
944            unsafe {
945                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
946            }
947            Ok(())
948        }
949    }
950
951    impl fidl::encoding::ValueTypeMarker for BalloonControllerGetMemStatsResponse {
952        type Borrowed<'a> = &'a Self;
953        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
954            value
955        }
956    }
957
958    unsafe impl fidl::encoding::TypeMarker for BalloonControllerGetMemStatsResponse {
959        type Owned = Self;
960
961        #[inline(always)]
962        fn inline_align(_context: fidl::encoding::Context) -> usize {
963            8
964        }
965
966        #[inline(always)]
967        fn inline_size(_context: fidl::encoding::Context) -> usize {
968            24
969        }
970    }
971
972    unsafe impl<D: fidl::encoding::ResourceDialect>
973        fidl::encoding::Encode<BalloonControllerGetMemStatsResponse, D>
974        for &BalloonControllerGetMemStatsResponse
975    {
976        #[inline]
977        unsafe fn encode(
978            self,
979            encoder: &mut fidl::encoding::Encoder<'_, D>,
980            offset: usize,
981            _depth: fidl::encoding::Depth,
982        ) -> fidl::Result<()> {
983            encoder.debug_check_bounds::<BalloonControllerGetMemStatsResponse>(offset);
984            // Delegate to tuple encoding.
985            fidl::encoding::Encode::<BalloonControllerGetMemStatsResponse, D>::encode(
986                (
987                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
988                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<MemStat>> as fidl::encoding::ValueTypeMarker>::borrow(&self.mem_stats),
989                ),
990                encoder, offset, _depth
991            )
992        }
993    }
994    unsafe impl<
995            D: fidl::encoding::ResourceDialect,
996            T0: fidl::encoding::Encode<i32, D>,
997            T1: fidl::encoding::Encode<
998                fidl::encoding::Optional<fidl::encoding::UnboundedVector<MemStat>>,
999                D,
1000            >,
1001        > fidl::encoding::Encode<BalloonControllerGetMemStatsResponse, D> for (T0, T1)
1002    {
1003        #[inline]
1004        unsafe fn encode(
1005            self,
1006            encoder: &mut fidl::encoding::Encoder<'_, D>,
1007            offset: usize,
1008            depth: fidl::encoding::Depth,
1009        ) -> fidl::Result<()> {
1010            encoder.debug_check_bounds::<BalloonControllerGetMemStatsResponse>(offset);
1011            // Zero out padding regions. There's no need to apply masks
1012            // because the unmasked parts will be overwritten by fields.
1013            unsafe {
1014                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1015                (ptr as *mut u64).write_unaligned(0);
1016            }
1017            // Write the fields.
1018            self.0.encode(encoder, offset + 0, depth)?;
1019            self.1.encode(encoder, offset + 8, depth)?;
1020            Ok(())
1021        }
1022    }
1023
1024    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1025        for BalloonControllerGetMemStatsResponse
1026    {
1027        #[inline(always)]
1028        fn new_empty() -> Self {
1029            Self {
1030                status: fidl::new_empty!(i32, D),
1031                mem_stats: fidl::new_empty!(
1032                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<MemStat>>,
1033                    D
1034                ),
1035            }
1036        }
1037
1038        #[inline]
1039        unsafe fn decode(
1040            &mut self,
1041            decoder: &mut fidl::encoding::Decoder<'_, D>,
1042            offset: usize,
1043            _depth: fidl::encoding::Depth,
1044        ) -> fidl::Result<()> {
1045            decoder.debug_check_bounds::<Self>(offset);
1046            // Verify that padding bytes are zero.
1047            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1048            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1049            let mask = 0xffffffff00000000u64;
1050            let maskedval = padval & mask;
1051            if maskedval != 0 {
1052                return Err(fidl::Error::NonZeroPadding {
1053                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1054                });
1055            }
1056            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
1057            fidl::decode!(
1058                fidl::encoding::Optional<fidl::encoding::UnboundedVector<MemStat>>,
1059                D,
1060                &mut self.mem_stats,
1061                decoder,
1062                offset + 8,
1063                _depth
1064            )?;
1065            Ok(())
1066        }
1067    }
1068
1069    impl fidl::encoding::ValueTypeMarker for BalloonControllerRequestNumPagesRequest {
1070        type Borrowed<'a> = &'a Self;
1071        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1072            value
1073        }
1074    }
1075
1076    unsafe impl fidl::encoding::TypeMarker for BalloonControllerRequestNumPagesRequest {
1077        type Owned = Self;
1078
1079        #[inline(always)]
1080        fn inline_align(_context: fidl::encoding::Context) -> usize {
1081            4
1082        }
1083
1084        #[inline(always)]
1085        fn inline_size(_context: fidl::encoding::Context) -> usize {
1086            4
1087        }
1088        #[inline(always)]
1089        fn encode_is_copy() -> bool {
1090            true
1091        }
1092
1093        #[inline(always)]
1094        fn decode_is_copy() -> bool {
1095            true
1096        }
1097    }
1098
1099    unsafe impl<D: fidl::encoding::ResourceDialect>
1100        fidl::encoding::Encode<BalloonControllerRequestNumPagesRequest, D>
1101        for &BalloonControllerRequestNumPagesRequest
1102    {
1103        #[inline]
1104        unsafe fn encode(
1105            self,
1106            encoder: &mut fidl::encoding::Encoder<'_, D>,
1107            offset: usize,
1108            _depth: fidl::encoding::Depth,
1109        ) -> fidl::Result<()> {
1110            encoder.debug_check_bounds::<BalloonControllerRequestNumPagesRequest>(offset);
1111            unsafe {
1112                // Copy the object into the buffer.
1113                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1114                (buf_ptr as *mut BalloonControllerRequestNumPagesRequest).write_unaligned(
1115                    (self as *const BalloonControllerRequestNumPagesRequest).read(),
1116                );
1117                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1118                // done second because the memcpy will write garbage to these bytes.
1119            }
1120            Ok(())
1121        }
1122    }
1123    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1124        fidl::encoding::Encode<BalloonControllerRequestNumPagesRequest, D> for (T0,)
1125    {
1126        #[inline]
1127        unsafe fn encode(
1128            self,
1129            encoder: &mut fidl::encoding::Encoder<'_, D>,
1130            offset: usize,
1131            depth: fidl::encoding::Depth,
1132        ) -> fidl::Result<()> {
1133            encoder.debug_check_bounds::<BalloonControllerRequestNumPagesRequest>(offset);
1134            // Zero out padding regions. There's no need to apply masks
1135            // because the unmasked parts will be overwritten by fields.
1136            // Write the fields.
1137            self.0.encode(encoder, offset + 0, depth)?;
1138            Ok(())
1139        }
1140    }
1141
1142    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1143        for BalloonControllerRequestNumPagesRequest
1144    {
1145        #[inline(always)]
1146        fn new_empty() -> Self {
1147            Self { requested_num_pages: fidl::new_empty!(u32, D) }
1148        }
1149
1150        #[inline]
1151        unsafe fn decode(
1152            &mut self,
1153            decoder: &mut fidl::encoding::Decoder<'_, D>,
1154            offset: usize,
1155            _depth: fidl::encoding::Depth,
1156        ) -> fidl::Result<()> {
1157            decoder.debug_check_bounds::<Self>(offset);
1158            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1159            // Verify that padding bytes are zero.
1160            // Copy from the buffer into the object.
1161            unsafe {
1162                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1163            }
1164            Ok(())
1165        }
1166    }
1167
1168    impl fidl::encoding::ValueTypeMarker for HostVsockAcceptorAcceptRequest {
1169        type Borrowed<'a> = &'a Self;
1170        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1171            value
1172        }
1173    }
1174
1175    unsafe impl fidl::encoding::TypeMarker for HostVsockAcceptorAcceptRequest {
1176        type Owned = Self;
1177
1178        #[inline(always)]
1179        fn inline_align(_context: fidl::encoding::Context) -> usize {
1180            4
1181        }
1182
1183        #[inline(always)]
1184        fn inline_size(_context: fidl::encoding::Context) -> usize {
1185            12
1186        }
1187        #[inline(always)]
1188        fn encode_is_copy() -> bool {
1189            true
1190        }
1191
1192        #[inline(always)]
1193        fn decode_is_copy() -> bool {
1194            true
1195        }
1196    }
1197
1198    unsafe impl<D: fidl::encoding::ResourceDialect>
1199        fidl::encoding::Encode<HostVsockAcceptorAcceptRequest, D>
1200        for &HostVsockAcceptorAcceptRequest
1201    {
1202        #[inline]
1203        unsafe fn encode(
1204            self,
1205            encoder: &mut fidl::encoding::Encoder<'_, D>,
1206            offset: usize,
1207            _depth: fidl::encoding::Depth,
1208        ) -> fidl::Result<()> {
1209            encoder.debug_check_bounds::<HostVsockAcceptorAcceptRequest>(offset);
1210            unsafe {
1211                // Copy the object into the buffer.
1212                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1213                (buf_ptr as *mut HostVsockAcceptorAcceptRequest)
1214                    .write_unaligned((self as *const HostVsockAcceptorAcceptRequest).read());
1215                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1216                // done second because the memcpy will write garbage to these bytes.
1217            }
1218            Ok(())
1219        }
1220    }
1221    unsafe impl<
1222            D: fidl::encoding::ResourceDialect,
1223            T0: fidl::encoding::Encode<u32, D>,
1224            T1: fidl::encoding::Encode<u32, D>,
1225            T2: fidl::encoding::Encode<u32, D>,
1226        > fidl::encoding::Encode<HostVsockAcceptorAcceptRequest, D> for (T0, T1, T2)
1227    {
1228        #[inline]
1229        unsafe fn encode(
1230            self,
1231            encoder: &mut fidl::encoding::Encoder<'_, D>,
1232            offset: usize,
1233            depth: fidl::encoding::Depth,
1234        ) -> fidl::Result<()> {
1235            encoder.debug_check_bounds::<HostVsockAcceptorAcceptRequest>(offset);
1236            // Zero out padding regions. There's no need to apply masks
1237            // because the unmasked parts will be overwritten by fields.
1238            // Write the fields.
1239            self.0.encode(encoder, offset + 0, depth)?;
1240            self.1.encode(encoder, offset + 4, depth)?;
1241            self.2.encode(encoder, offset + 8, depth)?;
1242            Ok(())
1243        }
1244    }
1245
1246    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1247        for HostVsockAcceptorAcceptRequest
1248    {
1249        #[inline(always)]
1250        fn new_empty() -> Self {
1251            Self {
1252                src_cid: fidl::new_empty!(u32, D),
1253                src_port: fidl::new_empty!(u32, D),
1254                port: fidl::new_empty!(u32, D),
1255            }
1256        }
1257
1258        #[inline]
1259        unsafe fn decode(
1260            &mut self,
1261            decoder: &mut fidl::encoding::Decoder<'_, D>,
1262            offset: usize,
1263            _depth: fidl::encoding::Depth,
1264        ) -> fidl::Result<()> {
1265            decoder.debug_check_bounds::<Self>(offset);
1266            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1267            // Verify that padding bytes are zero.
1268            // Copy from the buffer into the object.
1269            unsafe {
1270                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 12);
1271            }
1272            Ok(())
1273        }
1274    }
1275
1276    impl fidl::encoding::ValueTypeMarker for HostVsockEndpointConnectRequest {
1277        type Borrowed<'a> = &'a Self;
1278        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1279            value
1280        }
1281    }
1282
1283    unsafe impl fidl::encoding::TypeMarker for HostVsockEndpointConnectRequest {
1284        type Owned = Self;
1285
1286        #[inline(always)]
1287        fn inline_align(_context: fidl::encoding::Context) -> usize {
1288            4
1289        }
1290
1291        #[inline(always)]
1292        fn inline_size(_context: fidl::encoding::Context) -> usize {
1293            4
1294        }
1295        #[inline(always)]
1296        fn encode_is_copy() -> bool {
1297            true
1298        }
1299
1300        #[inline(always)]
1301        fn decode_is_copy() -> bool {
1302            true
1303        }
1304    }
1305
1306    unsafe impl<D: fidl::encoding::ResourceDialect>
1307        fidl::encoding::Encode<HostVsockEndpointConnectRequest, D>
1308        for &HostVsockEndpointConnectRequest
1309    {
1310        #[inline]
1311        unsafe fn encode(
1312            self,
1313            encoder: &mut fidl::encoding::Encoder<'_, D>,
1314            offset: usize,
1315            _depth: fidl::encoding::Depth,
1316        ) -> fidl::Result<()> {
1317            encoder.debug_check_bounds::<HostVsockEndpointConnectRequest>(offset);
1318            unsafe {
1319                // Copy the object into the buffer.
1320                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1321                (buf_ptr as *mut HostVsockEndpointConnectRequest)
1322                    .write_unaligned((self as *const HostVsockEndpointConnectRequest).read());
1323                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1324                // done second because the memcpy will write garbage to these bytes.
1325            }
1326            Ok(())
1327        }
1328    }
1329    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1330        fidl::encoding::Encode<HostVsockEndpointConnectRequest, D> for (T0,)
1331    {
1332        #[inline]
1333        unsafe fn encode(
1334            self,
1335            encoder: &mut fidl::encoding::Encoder<'_, D>,
1336            offset: usize,
1337            depth: fidl::encoding::Depth,
1338        ) -> fidl::Result<()> {
1339            encoder.debug_check_bounds::<HostVsockEndpointConnectRequest>(offset);
1340            // Zero out padding regions. There's no need to apply masks
1341            // because the unmasked parts will be overwritten by fields.
1342            // Write the fields.
1343            self.0.encode(encoder, offset + 0, depth)?;
1344            Ok(())
1345        }
1346    }
1347
1348    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1349        for HostVsockEndpointConnectRequest
1350    {
1351        #[inline(always)]
1352        fn new_empty() -> Self {
1353            Self { guest_port: fidl::new_empty!(u32, D) }
1354        }
1355
1356        #[inline]
1357        unsafe fn decode(
1358            &mut self,
1359            decoder: &mut fidl::encoding::Decoder<'_, D>,
1360            offset: usize,
1361            _depth: fidl::encoding::Depth,
1362        ) -> fidl::Result<()> {
1363            decoder.debug_check_bounds::<Self>(offset);
1364            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1365            // Verify that padding bytes are zero.
1366            // Copy from the buffer into the object.
1367            unsafe {
1368                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1369            }
1370            Ok(())
1371        }
1372    }
1373
1374    impl fidl::encoding::ValueTypeMarker for LinuxManagerOnGuestInfoChangedRequest {
1375        type Borrowed<'a> = &'a Self;
1376        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1377            value
1378        }
1379    }
1380
1381    unsafe impl fidl::encoding::TypeMarker for LinuxManagerOnGuestInfoChangedRequest {
1382        type Owned = Self;
1383
1384        #[inline(always)]
1385        fn inline_align(_context: fidl::encoding::Context) -> usize {
1386            8
1387        }
1388
1389        #[inline(always)]
1390        fn inline_size(_context: fidl::encoding::Context) -> usize {
1391            32
1392        }
1393    }
1394
1395    unsafe impl<D: fidl::encoding::ResourceDialect>
1396        fidl::encoding::Encode<LinuxManagerOnGuestInfoChangedRequest, D>
1397        for &LinuxManagerOnGuestInfoChangedRequest
1398    {
1399        #[inline]
1400        unsafe fn encode(
1401            self,
1402            encoder: &mut fidl::encoding::Encoder<'_, D>,
1403            offset: usize,
1404            _depth: fidl::encoding::Depth,
1405        ) -> fidl::Result<()> {
1406            encoder.debug_check_bounds::<LinuxManagerOnGuestInfoChangedRequest>(offset);
1407            // Delegate to tuple encoding.
1408            fidl::encoding::Encode::<LinuxManagerOnGuestInfoChangedRequest, D>::encode(
1409                (
1410                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
1411                        &self.label,
1412                    ),
1413                    <LinuxGuestInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
1414                ),
1415                encoder,
1416                offset,
1417                _depth,
1418            )
1419        }
1420    }
1421    unsafe impl<
1422            D: fidl::encoding::ResourceDialect,
1423            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1424            T1: fidl::encoding::Encode<LinuxGuestInfo, D>,
1425        > fidl::encoding::Encode<LinuxManagerOnGuestInfoChangedRequest, D> for (T0, T1)
1426    {
1427        #[inline]
1428        unsafe fn encode(
1429            self,
1430            encoder: &mut fidl::encoding::Encoder<'_, D>,
1431            offset: usize,
1432            depth: fidl::encoding::Depth,
1433        ) -> fidl::Result<()> {
1434            encoder.debug_check_bounds::<LinuxManagerOnGuestInfoChangedRequest>(offset);
1435            // Zero out padding regions. There's no need to apply masks
1436            // because the unmasked parts will be overwritten by fields.
1437            // Write the fields.
1438            self.0.encode(encoder, offset + 0, depth)?;
1439            self.1.encode(encoder, offset + 16, depth)?;
1440            Ok(())
1441        }
1442    }
1443
1444    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1445        for LinuxManagerOnGuestInfoChangedRequest
1446    {
1447        #[inline(always)]
1448        fn new_empty() -> Self {
1449            Self {
1450                label: fidl::new_empty!(fidl::encoding::UnboundedString, D),
1451                info: fidl::new_empty!(LinuxGuestInfo, D),
1452            }
1453        }
1454
1455        #[inline]
1456        unsafe fn decode(
1457            &mut self,
1458            decoder: &mut fidl::encoding::Decoder<'_, D>,
1459            offset: usize,
1460            _depth: fidl::encoding::Depth,
1461        ) -> fidl::Result<()> {
1462            decoder.debug_check_bounds::<Self>(offset);
1463            // Verify that padding bytes are zero.
1464            fidl::decode!(
1465                fidl::encoding::UnboundedString,
1466                D,
1467                &mut self.label,
1468                decoder,
1469                offset + 0,
1470                _depth
1471            )?;
1472            fidl::decode!(LinuxGuestInfo, D, &mut self.info, decoder, offset + 16, _depth)?;
1473            Ok(())
1474        }
1475    }
1476
1477    impl fidl::encoding::ValueTypeMarker for LinuxManagerStartAndGetLinuxGuestInfoRequest {
1478        type Borrowed<'a> = &'a Self;
1479        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1480            value
1481        }
1482    }
1483
1484    unsafe impl fidl::encoding::TypeMarker for LinuxManagerStartAndGetLinuxGuestInfoRequest {
1485        type Owned = Self;
1486
1487        #[inline(always)]
1488        fn inline_align(_context: fidl::encoding::Context) -> usize {
1489            8
1490        }
1491
1492        #[inline(always)]
1493        fn inline_size(_context: fidl::encoding::Context) -> usize {
1494            16
1495        }
1496    }
1497
1498    unsafe impl<D: fidl::encoding::ResourceDialect>
1499        fidl::encoding::Encode<LinuxManagerStartAndGetLinuxGuestInfoRequest, D>
1500        for &LinuxManagerStartAndGetLinuxGuestInfoRequest
1501    {
1502        #[inline]
1503        unsafe fn encode(
1504            self,
1505            encoder: &mut fidl::encoding::Encoder<'_, D>,
1506            offset: usize,
1507            _depth: fidl::encoding::Depth,
1508        ) -> fidl::Result<()> {
1509            encoder.debug_check_bounds::<LinuxManagerStartAndGetLinuxGuestInfoRequest>(offset);
1510            // Delegate to tuple encoding.
1511            fidl::encoding::Encode::<LinuxManagerStartAndGetLinuxGuestInfoRequest, D>::encode(
1512                (<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
1513                    &self.label,
1514                ),),
1515                encoder,
1516                offset,
1517                _depth,
1518            )
1519        }
1520    }
1521    unsafe impl<
1522            D: fidl::encoding::ResourceDialect,
1523            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1524        > fidl::encoding::Encode<LinuxManagerStartAndGetLinuxGuestInfoRequest, D> for (T0,)
1525    {
1526        #[inline]
1527        unsafe fn encode(
1528            self,
1529            encoder: &mut fidl::encoding::Encoder<'_, D>,
1530            offset: usize,
1531            depth: fidl::encoding::Depth,
1532        ) -> fidl::Result<()> {
1533            encoder.debug_check_bounds::<LinuxManagerStartAndGetLinuxGuestInfoRequest>(offset);
1534            // Zero out padding regions. There's no need to apply masks
1535            // because the unmasked parts will be overwritten by fields.
1536            // Write the fields.
1537            self.0.encode(encoder, offset + 0, depth)?;
1538            Ok(())
1539        }
1540    }
1541
1542    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1543        for LinuxManagerStartAndGetLinuxGuestInfoRequest
1544    {
1545        #[inline(always)]
1546        fn new_empty() -> Self {
1547            Self { label: fidl::new_empty!(fidl::encoding::UnboundedString, D) }
1548        }
1549
1550        #[inline]
1551        unsafe fn decode(
1552            &mut self,
1553            decoder: &mut fidl::encoding::Decoder<'_, D>,
1554            offset: usize,
1555            _depth: fidl::encoding::Depth,
1556        ) -> fidl::Result<()> {
1557            decoder.debug_check_bounds::<Self>(offset);
1558            // Verify that padding bytes are zero.
1559            fidl::decode!(
1560                fidl::encoding::UnboundedString,
1561                D,
1562                &mut self.label,
1563                decoder,
1564                offset + 0,
1565                _depth
1566            )?;
1567            Ok(())
1568        }
1569    }
1570
1571    impl fidl::encoding::ValueTypeMarker for LinuxManagerStartAndGetLinuxGuestInfoResponse {
1572        type Borrowed<'a> = &'a Self;
1573        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1574            value
1575        }
1576    }
1577
1578    unsafe impl fidl::encoding::TypeMarker for LinuxManagerStartAndGetLinuxGuestInfoResponse {
1579        type Owned = Self;
1580
1581        #[inline(always)]
1582        fn inline_align(_context: fidl::encoding::Context) -> usize {
1583            8
1584        }
1585
1586        #[inline(always)]
1587        fn inline_size(_context: fidl::encoding::Context) -> usize {
1588            16
1589        }
1590    }
1591
1592    unsafe impl<D: fidl::encoding::ResourceDialect>
1593        fidl::encoding::Encode<LinuxManagerStartAndGetLinuxGuestInfoResponse, D>
1594        for &LinuxManagerStartAndGetLinuxGuestInfoResponse
1595    {
1596        #[inline]
1597        unsafe fn encode(
1598            self,
1599            encoder: &mut fidl::encoding::Encoder<'_, D>,
1600            offset: usize,
1601            _depth: fidl::encoding::Depth,
1602        ) -> fidl::Result<()> {
1603            encoder.debug_check_bounds::<LinuxManagerStartAndGetLinuxGuestInfoResponse>(offset);
1604            // Delegate to tuple encoding.
1605            fidl::encoding::Encode::<LinuxManagerStartAndGetLinuxGuestInfoResponse, D>::encode(
1606                (<LinuxGuestInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
1607                encoder,
1608                offset,
1609                _depth,
1610            )
1611        }
1612    }
1613    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<LinuxGuestInfo, D>>
1614        fidl::encoding::Encode<LinuxManagerStartAndGetLinuxGuestInfoResponse, D> for (T0,)
1615    {
1616        #[inline]
1617        unsafe fn encode(
1618            self,
1619            encoder: &mut fidl::encoding::Encoder<'_, D>,
1620            offset: usize,
1621            depth: fidl::encoding::Depth,
1622        ) -> fidl::Result<()> {
1623            encoder.debug_check_bounds::<LinuxManagerStartAndGetLinuxGuestInfoResponse>(offset);
1624            // Zero out padding regions. There's no need to apply masks
1625            // because the unmasked parts will be overwritten by fields.
1626            // Write the fields.
1627            self.0.encode(encoder, offset + 0, depth)?;
1628            Ok(())
1629        }
1630    }
1631
1632    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1633        for LinuxManagerStartAndGetLinuxGuestInfoResponse
1634    {
1635        #[inline(always)]
1636        fn new_empty() -> Self {
1637            Self { info: fidl::new_empty!(LinuxGuestInfo, D) }
1638        }
1639
1640        #[inline]
1641        unsafe fn decode(
1642            &mut self,
1643            decoder: &mut fidl::encoding::Decoder<'_, D>,
1644            offset: usize,
1645            _depth: fidl::encoding::Depth,
1646        ) -> fidl::Result<()> {
1647            decoder.debug_check_bounds::<Self>(offset);
1648            // Verify that padding bytes are zero.
1649            fidl::decode!(LinuxGuestInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
1650            Ok(())
1651        }
1652    }
1653
1654    impl fidl::encoding::ValueTypeMarker for MagmaDevice {
1655        type Borrowed<'a> = &'a Self;
1656        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1657            value
1658        }
1659    }
1660
1661    unsafe impl fidl::encoding::TypeMarker for MagmaDevice {
1662        type Owned = Self;
1663
1664        #[inline(always)]
1665        fn inline_align(_context: fidl::encoding::Context) -> usize {
1666            8
1667        }
1668
1669        #[inline(always)]
1670        fn inline_size(_context: fidl::encoding::Context) -> usize {
1671            8
1672        }
1673        #[inline(always)]
1674        fn encode_is_copy() -> bool {
1675            true
1676        }
1677
1678        #[inline(always)]
1679        fn decode_is_copy() -> bool {
1680            true
1681        }
1682    }
1683
1684    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MagmaDevice, D>
1685        for &MagmaDevice
1686    {
1687        #[inline]
1688        unsafe fn encode(
1689            self,
1690            encoder: &mut fidl::encoding::Encoder<'_, D>,
1691            offset: usize,
1692            _depth: fidl::encoding::Depth,
1693        ) -> fidl::Result<()> {
1694            encoder.debug_check_bounds::<MagmaDevice>(offset);
1695            unsafe {
1696                // Copy the object into the buffer.
1697                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1698                (buf_ptr as *mut MagmaDevice).write_unaligned((self as *const MagmaDevice).read());
1699                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1700                // done second because the memcpy will write garbage to these bytes.
1701            }
1702            Ok(())
1703        }
1704    }
1705    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
1706        fidl::encoding::Encode<MagmaDevice, D> for (T0,)
1707    {
1708        #[inline]
1709        unsafe fn encode(
1710            self,
1711            encoder: &mut fidl::encoding::Encoder<'_, D>,
1712            offset: usize,
1713            depth: fidl::encoding::Depth,
1714        ) -> fidl::Result<()> {
1715            encoder.debug_check_bounds::<MagmaDevice>(offset);
1716            // Zero out padding regions. There's no need to apply masks
1717            // because the unmasked parts will be overwritten by fields.
1718            // Write the fields.
1719            self.0.encode(encoder, offset + 0, depth)?;
1720            Ok(())
1721        }
1722    }
1723
1724    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MagmaDevice {
1725        #[inline(always)]
1726        fn new_empty() -> Self {
1727            Self { memory: fidl::new_empty!(u64, D) }
1728        }
1729
1730        #[inline]
1731        unsafe fn decode(
1732            &mut self,
1733            decoder: &mut fidl::encoding::Decoder<'_, D>,
1734            offset: usize,
1735            _depth: fidl::encoding::Depth,
1736        ) -> fidl::Result<()> {
1737            decoder.debug_check_bounds::<Self>(offset);
1738            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1739            // Verify that padding bytes are zero.
1740            // Copy from the buffer into the object.
1741            unsafe {
1742                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1743            }
1744            Ok(())
1745        }
1746    }
1747
1748    impl fidl::encoding::ValueTypeMarker for MemControllerGetMemSizeResponse {
1749        type Borrowed<'a> = &'a Self;
1750        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1751            value
1752        }
1753    }
1754
1755    unsafe impl fidl::encoding::TypeMarker for MemControllerGetMemSizeResponse {
1756        type Owned = Self;
1757
1758        #[inline(always)]
1759        fn inline_align(_context: fidl::encoding::Context) -> usize {
1760            8
1761        }
1762
1763        #[inline(always)]
1764        fn inline_size(_context: fidl::encoding::Context) -> usize {
1765            40
1766        }
1767        #[inline(always)]
1768        fn encode_is_copy() -> bool {
1769            true
1770        }
1771
1772        #[inline(always)]
1773        fn decode_is_copy() -> bool {
1774            true
1775        }
1776    }
1777
1778    unsafe impl<D: fidl::encoding::ResourceDialect>
1779        fidl::encoding::Encode<MemControllerGetMemSizeResponse, D>
1780        for &MemControllerGetMemSizeResponse
1781    {
1782        #[inline]
1783        unsafe fn encode(
1784            self,
1785            encoder: &mut fidl::encoding::Encoder<'_, D>,
1786            offset: usize,
1787            _depth: fidl::encoding::Depth,
1788        ) -> fidl::Result<()> {
1789            encoder.debug_check_bounds::<MemControllerGetMemSizeResponse>(offset);
1790            unsafe {
1791                // Copy the object into the buffer.
1792                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1793                (buf_ptr as *mut MemControllerGetMemSizeResponse)
1794                    .write_unaligned((self as *const MemControllerGetMemSizeResponse).read());
1795                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1796                // done second because the memcpy will write garbage to these bytes.
1797            }
1798            Ok(())
1799        }
1800    }
1801    unsafe impl<
1802            D: fidl::encoding::ResourceDialect,
1803            T0: fidl::encoding::Encode<u64, D>,
1804            T1: fidl::encoding::Encode<u64, D>,
1805            T2: fidl::encoding::Encode<u64, D>,
1806            T3: fidl::encoding::Encode<u64, D>,
1807            T4: fidl::encoding::Encode<u64, D>,
1808        > fidl::encoding::Encode<MemControllerGetMemSizeResponse, D> for (T0, T1, T2, T3, T4)
1809    {
1810        #[inline]
1811        unsafe fn encode(
1812            self,
1813            encoder: &mut fidl::encoding::Encoder<'_, D>,
1814            offset: usize,
1815            depth: fidl::encoding::Depth,
1816        ) -> fidl::Result<()> {
1817            encoder.debug_check_bounds::<MemControllerGetMemSizeResponse>(offset);
1818            // Zero out padding regions. There's no need to apply masks
1819            // because the unmasked parts will be overwritten by fields.
1820            // Write the fields.
1821            self.0.encode(encoder, offset + 0, depth)?;
1822            self.1.encode(encoder, offset + 8, depth)?;
1823            self.2.encode(encoder, offset + 16, depth)?;
1824            self.3.encode(encoder, offset + 24, depth)?;
1825            self.4.encode(encoder, offset + 32, depth)?;
1826            Ok(())
1827        }
1828    }
1829
1830    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1831        for MemControllerGetMemSizeResponse
1832    {
1833        #[inline(always)]
1834        fn new_empty() -> Self {
1835            Self {
1836                block_size: fidl::new_empty!(u64, D),
1837                region_size: fidl::new_empty!(u64, D),
1838                usable_region_size: fidl::new_empty!(u64, D),
1839                plugged_size: fidl::new_empty!(u64, D),
1840                requested_size: fidl::new_empty!(u64, D),
1841            }
1842        }
1843
1844        #[inline]
1845        unsafe fn decode(
1846            &mut self,
1847            decoder: &mut fidl::encoding::Decoder<'_, D>,
1848            offset: usize,
1849            _depth: fidl::encoding::Depth,
1850        ) -> fidl::Result<()> {
1851            decoder.debug_check_bounds::<Self>(offset);
1852            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1853            // Verify that padding bytes are zero.
1854            // Copy from the buffer into the object.
1855            unsafe {
1856                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
1857            }
1858            Ok(())
1859        }
1860    }
1861
1862    impl fidl::encoding::ValueTypeMarker for MemControllerRequestSizeRequest {
1863        type Borrowed<'a> = &'a Self;
1864        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1865            value
1866        }
1867    }
1868
1869    unsafe impl fidl::encoding::TypeMarker for MemControllerRequestSizeRequest {
1870        type Owned = Self;
1871
1872        #[inline(always)]
1873        fn inline_align(_context: fidl::encoding::Context) -> usize {
1874            8
1875        }
1876
1877        #[inline(always)]
1878        fn inline_size(_context: fidl::encoding::Context) -> usize {
1879            8
1880        }
1881        #[inline(always)]
1882        fn encode_is_copy() -> bool {
1883            true
1884        }
1885
1886        #[inline(always)]
1887        fn decode_is_copy() -> bool {
1888            true
1889        }
1890    }
1891
1892    unsafe impl<D: fidl::encoding::ResourceDialect>
1893        fidl::encoding::Encode<MemControllerRequestSizeRequest, D>
1894        for &MemControllerRequestSizeRequest
1895    {
1896        #[inline]
1897        unsafe fn encode(
1898            self,
1899            encoder: &mut fidl::encoding::Encoder<'_, D>,
1900            offset: usize,
1901            _depth: fidl::encoding::Depth,
1902        ) -> fidl::Result<()> {
1903            encoder.debug_check_bounds::<MemControllerRequestSizeRequest>(offset);
1904            unsafe {
1905                // Copy the object into the buffer.
1906                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1907                (buf_ptr as *mut MemControllerRequestSizeRequest)
1908                    .write_unaligned((self as *const MemControllerRequestSizeRequest).read());
1909                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1910                // done second because the memcpy will write garbage to these bytes.
1911            }
1912            Ok(())
1913        }
1914    }
1915    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
1916        fidl::encoding::Encode<MemControllerRequestSizeRequest, D> for (T0,)
1917    {
1918        #[inline]
1919        unsafe fn encode(
1920            self,
1921            encoder: &mut fidl::encoding::Encoder<'_, D>,
1922            offset: usize,
1923            depth: fidl::encoding::Depth,
1924        ) -> fidl::Result<()> {
1925            encoder.debug_check_bounds::<MemControllerRequestSizeRequest>(offset);
1926            // Zero out padding regions. There's no need to apply masks
1927            // because the unmasked parts will be overwritten by fields.
1928            // Write the fields.
1929            self.0.encode(encoder, offset + 0, depth)?;
1930            Ok(())
1931        }
1932    }
1933
1934    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1935        for MemControllerRequestSizeRequest
1936    {
1937        #[inline(always)]
1938        fn new_empty() -> Self {
1939            Self { requested_size: fidl::new_empty!(u64, D) }
1940        }
1941
1942        #[inline]
1943        unsafe fn decode(
1944            &mut self,
1945            decoder: &mut fidl::encoding::Decoder<'_, D>,
1946            offset: usize,
1947            _depth: fidl::encoding::Depth,
1948        ) -> fidl::Result<()> {
1949            decoder.debug_check_bounds::<Self>(offset);
1950            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1951            // Verify that padding bytes are zero.
1952            // Copy from the buffer into the object.
1953            unsafe {
1954                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1955            }
1956            Ok(())
1957        }
1958    }
1959
1960    impl fidl::encoding::ValueTypeMarker for MemStat {
1961        type Borrowed<'a> = &'a Self;
1962        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1963            value
1964        }
1965    }
1966
1967    unsafe impl fidl::encoding::TypeMarker for MemStat {
1968        type Owned = Self;
1969
1970        #[inline(always)]
1971        fn inline_align(_context: fidl::encoding::Context) -> usize {
1972            8
1973        }
1974
1975        #[inline(always)]
1976        fn inline_size(_context: fidl::encoding::Context) -> usize {
1977            16
1978        }
1979    }
1980
1981    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MemStat, D> for &MemStat {
1982        #[inline]
1983        unsafe fn encode(
1984            self,
1985            encoder: &mut fidl::encoding::Encoder<'_, D>,
1986            offset: usize,
1987            _depth: fidl::encoding::Depth,
1988        ) -> fidl::Result<()> {
1989            encoder.debug_check_bounds::<MemStat>(offset);
1990            unsafe {
1991                // Copy the object into the buffer.
1992                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1993                (buf_ptr as *mut MemStat).write_unaligned((self as *const MemStat).read());
1994                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1995                // done second because the memcpy will write garbage to these bytes.
1996                let padding_ptr = buf_ptr.offset(0) as *mut u64;
1997                let padding_mask = 0xffffffffffff0000u64;
1998                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
1999            }
2000            Ok(())
2001        }
2002    }
2003    unsafe impl<
2004            D: fidl::encoding::ResourceDialect,
2005            T0: fidl::encoding::Encode<u16, D>,
2006            T1: fidl::encoding::Encode<u64, D>,
2007        > fidl::encoding::Encode<MemStat, D> for (T0, T1)
2008    {
2009        #[inline]
2010        unsafe fn encode(
2011            self,
2012            encoder: &mut fidl::encoding::Encoder<'_, D>,
2013            offset: usize,
2014            depth: fidl::encoding::Depth,
2015        ) -> fidl::Result<()> {
2016            encoder.debug_check_bounds::<MemStat>(offset);
2017            // Zero out padding regions. There's no need to apply masks
2018            // because the unmasked parts will be overwritten by fields.
2019            unsafe {
2020                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2021                (ptr as *mut u64).write_unaligned(0);
2022            }
2023            // Write the fields.
2024            self.0.encode(encoder, offset + 0, depth)?;
2025            self.1.encode(encoder, offset + 8, depth)?;
2026            Ok(())
2027        }
2028    }
2029
2030    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MemStat {
2031        #[inline(always)]
2032        fn new_empty() -> Self {
2033            Self { tag: fidl::new_empty!(u16, D), val: fidl::new_empty!(u64, D) }
2034        }
2035
2036        #[inline]
2037        unsafe fn decode(
2038            &mut self,
2039            decoder: &mut fidl::encoding::Decoder<'_, D>,
2040            offset: usize,
2041            _depth: fidl::encoding::Depth,
2042        ) -> fidl::Result<()> {
2043            decoder.debug_check_bounds::<Self>(offset);
2044            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2045            // Verify that padding bytes are zero.
2046            let ptr = unsafe { buf_ptr.offset(0) };
2047            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2048            let mask = 0xffffffffffff0000u64;
2049            let maskedval = padval & mask;
2050            if maskedval != 0 {
2051                return Err(fidl::Error::NonZeroPadding {
2052                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2053                });
2054            }
2055            // Copy from the buffer into the object.
2056            unsafe {
2057                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2058            }
2059            Ok(())
2060        }
2061    }
2062
2063    impl fidl::encoding::ValueTypeMarker for NetSpec {
2064        type Borrowed<'a> = &'a Self;
2065        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2066            value
2067        }
2068    }
2069
2070    unsafe impl fidl::encoding::TypeMarker for NetSpec {
2071        type Owned = Self;
2072
2073        #[inline(always)]
2074        fn inline_align(_context: fidl::encoding::Context) -> usize {
2075            1
2076        }
2077
2078        #[inline(always)]
2079        fn inline_size(_context: fidl::encoding::Context) -> usize {
2080            7
2081        }
2082    }
2083
2084    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NetSpec, D> for &NetSpec {
2085        #[inline]
2086        unsafe fn encode(
2087            self,
2088            encoder: &mut fidl::encoding::Encoder<'_, D>,
2089            offset: usize,
2090            _depth: fidl::encoding::Depth,
2091        ) -> fidl::Result<()> {
2092            encoder.debug_check_bounds::<NetSpec>(offset);
2093            // Delegate to tuple encoding.
2094            fidl::encoding::Encode::<NetSpec, D>::encode(
2095                (
2096                    <fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.mac_address),
2097                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enable_bridge),
2098                ),
2099                encoder, offset, _depth
2100            )
2101        }
2102    }
2103    unsafe impl<
2104            D: fidl::encoding::ResourceDialect,
2105            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::MacAddress, D>,
2106            T1: fidl::encoding::Encode<bool, D>,
2107        > fidl::encoding::Encode<NetSpec, D> for (T0, T1)
2108    {
2109        #[inline]
2110        unsafe fn encode(
2111            self,
2112            encoder: &mut fidl::encoding::Encoder<'_, D>,
2113            offset: usize,
2114            depth: fidl::encoding::Depth,
2115        ) -> fidl::Result<()> {
2116            encoder.debug_check_bounds::<NetSpec>(offset);
2117            // Zero out padding regions. There's no need to apply masks
2118            // because the unmasked parts will be overwritten by fields.
2119            // Write the fields.
2120            self.0.encode(encoder, offset + 0, depth)?;
2121            self.1.encode(encoder, offset + 6, depth)?;
2122            Ok(())
2123        }
2124    }
2125
2126    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NetSpec {
2127        #[inline(always)]
2128        fn new_empty() -> Self {
2129            Self {
2130                mac_address: fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D),
2131                enable_bridge: fidl::new_empty!(bool, D),
2132            }
2133        }
2134
2135        #[inline]
2136        unsafe fn decode(
2137            &mut self,
2138            decoder: &mut fidl::encoding::Decoder<'_, D>,
2139            offset: usize,
2140            _depth: fidl::encoding::Depth,
2141        ) -> fidl::Result<()> {
2142            decoder.debug_check_bounds::<Self>(offset);
2143            // Verify that padding bytes are zero.
2144            fidl::decode!(
2145                fidl_fuchsia_net__common::MacAddress,
2146                D,
2147                &mut self.mac_address,
2148                decoder,
2149                offset + 0,
2150                _depth
2151            )?;
2152            fidl::decode!(bool, D, &mut self.enable_bridge, decoder, offset + 6, _depth)?;
2153            Ok(())
2154        }
2155    }
2156
2157    impl GuestDescriptor {
2158        #[inline(always)]
2159        fn max_ordinal_present(&self) -> u64 {
2160            if let Some(_) = self.mem {
2161                return 12;
2162            }
2163            if let Some(_) = self.networks {
2164                return 11;
2165            }
2166            if let Some(_) = self.sound {
2167                return 10;
2168            }
2169            if let Some(_) = self.vsock {
2170                return 9;
2171            }
2172            if let Some(_) = self.rng {
2173                return 8;
2174            }
2175            if let Some(_) = self.gpu {
2176                return 7;
2177            }
2178            if let Some(_) = self.console {
2179                return 6;
2180            }
2181            if let Some(_) = self.balloon {
2182                return 5;
2183            }
2184            if let Some(_) = self.magma {
2185                return 4;
2186            }
2187            if let Some(_) = self.wayland {
2188                return 3;
2189            }
2190            if let Some(_) = self.guest_memory {
2191                return 2;
2192            }
2193            if let Some(_) = self.num_cpus {
2194                return 1;
2195            }
2196            0
2197        }
2198    }
2199
2200    impl fidl::encoding::ValueTypeMarker for GuestDescriptor {
2201        type Borrowed<'a> = &'a Self;
2202        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2203            value
2204        }
2205    }
2206
2207    unsafe impl fidl::encoding::TypeMarker for GuestDescriptor {
2208        type Owned = Self;
2209
2210        #[inline(always)]
2211        fn inline_align(_context: fidl::encoding::Context) -> usize {
2212            8
2213        }
2214
2215        #[inline(always)]
2216        fn inline_size(_context: fidl::encoding::Context) -> usize {
2217            16
2218        }
2219    }
2220
2221    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GuestDescriptor, D>
2222        for &GuestDescriptor
2223    {
2224        unsafe fn encode(
2225            self,
2226            encoder: &mut fidl::encoding::Encoder<'_, D>,
2227            offset: usize,
2228            mut depth: fidl::encoding::Depth,
2229        ) -> fidl::Result<()> {
2230            encoder.debug_check_bounds::<GuestDescriptor>(offset);
2231            // Vector header
2232            let max_ordinal: u64 = self.max_ordinal_present();
2233            encoder.write_num(max_ordinal, offset);
2234            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2235            // Calling encoder.out_of_line_offset(0) is not allowed.
2236            if max_ordinal == 0 {
2237                return Ok(());
2238            }
2239            depth.increment()?;
2240            let envelope_size = 8;
2241            let bytes_len = max_ordinal as usize * envelope_size;
2242            #[allow(unused_variables)]
2243            let offset = encoder.out_of_line_offset(bytes_len);
2244            let mut _prev_end_offset: usize = 0;
2245            if 1 > max_ordinal {
2246                return Ok(());
2247            }
2248
2249            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2250            // are envelope_size bytes.
2251            let cur_offset: usize = (1 - 1) * envelope_size;
2252
2253            // Zero reserved fields.
2254            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2255
2256            // Safety:
2257            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2258            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2259            //   envelope_size bytes, there is always sufficient room.
2260            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2261                self.num_cpus.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2262                encoder,
2263                offset + cur_offset,
2264                depth,
2265            )?;
2266
2267            _prev_end_offset = cur_offset + envelope_size;
2268            if 2 > max_ordinal {
2269                return Ok(());
2270            }
2271
2272            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2273            // are envelope_size bytes.
2274            let cur_offset: usize = (2 - 1) * envelope_size;
2275
2276            // Zero reserved fields.
2277            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2278
2279            // Safety:
2280            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2281            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2282            //   envelope_size bytes, there is always sufficient room.
2283            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2284                self.guest_memory.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2285                encoder,
2286                offset + cur_offset,
2287                depth,
2288            )?;
2289
2290            _prev_end_offset = cur_offset + envelope_size;
2291            if 3 > max_ordinal {
2292                return Ok(());
2293            }
2294
2295            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2296            // are envelope_size bytes.
2297            let cur_offset: usize = (3 - 1) * envelope_size;
2298
2299            // Zero reserved fields.
2300            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2301
2302            // Safety:
2303            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2304            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2305            //   envelope_size bytes, there is always sufficient room.
2306            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2307                self.wayland.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2308                encoder,
2309                offset + cur_offset,
2310                depth,
2311            )?;
2312
2313            _prev_end_offset = cur_offset + envelope_size;
2314            if 4 > max_ordinal {
2315                return Ok(());
2316            }
2317
2318            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2319            // are envelope_size bytes.
2320            let cur_offset: usize = (4 - 1) * envelope_size;
2321
2322            // Zero reserved fields.
2323            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2324
2325            // Safety:
2326            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2327            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2328            //   envelope_size bytes, there is always sufficient room.
2329            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2330                self.magma.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2331                encoder,
2332                offset + cur_offset,
2333                depth,
2334            )?;
2335
2336            _prev_end_offset = cur_offset + envelope_size;
2337            if 5 > max_ordinal {
2338                return Ok(());
2339            }
2340
2341            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2342            // are envelope_size bytes.
2343            let cur_offset: usize = (5 - 1) * envelope_size;
2344
2345            // Zero reserved fields.
2346            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2347
2348            // Safety:
2349            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2350            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2351            //   envelope_size bytes, there is always sufficient room.
2352            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2353                self.balloon.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2354                encoder,
2355                offset + cur_offset,
2356                depth,
2357            )?;
2358
2359            _prev_end_offset = cur_offset + envelope_size;
2360            if 6 > max_ordinal {
2361                return Ok(());
2362            }
2363
2364            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2365            // are envelope_size bytes.
2366            let cur_offset: usize = (6 - 1) * envelope_size;
2367
2368            // Zero reserved fields.
2369            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2370
2371            // Safety:
2372            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2373            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2374            //   envelope_size bytes, there is always sufficient room.
2375            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2376                self.console.as_ref().map(<bool 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 7 > max_ordinal {
2384                return Ok(());
2385            }
2386
2387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2388            // are envelope_size bytes.
2389            let cur_offset: usize = (7 - 1) * envelope_size;
2390
2391            // Zero reserved fields.
2392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2393
2394            // Safety:
2395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2397            //   envelope_size bytes, there is always sufficient room.
2398            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2399                self.gpu.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2400                encoder,
2401                offset + cur_offset,
2402                depth,
2403            )?;
2404
2405            _prev_end_offset = cur_offset + envelope_size;
2406            if 8 > max_ordinal {
2407                return Ok(());
2408            }
2409
2410            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2411            // are envelope_size bytes.
2412            let cur_offset: usize = (8 - 1) * envelope_size;
2413
2414            // Zero reserved fields.
2415            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2416
2417            // Safety:
2418            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2419            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2420            //   envelope_size bytes, there is always sufficient room.
2421            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2422                self.rng.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2423                encoder,
2424                offset + cur_offset,
2425                depth,
2426            )?;
2427
2428            _prev_end_offset = cur_offset + envelope_size;
2429            if 9 > max_ordinal {
2430                return Ok(());
2431            }
2432
2433            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2434            // are envelope_size bytes.
2435            let cur_offset: usize = (9 - 1) * envelope_size;
2436
2437            // Zero reserved fields.
2438            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2439
2440            // Safety:
2441            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2442            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2443            //   envelope_size bytes, there is always sufficient room.
2444            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2445                self.vsock.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2446                encoder,
2447                offset + cur_offset,
2448                depth,
2449            )?;
2450
2451            _prev_end_offset = cur_offset + envelope_size;
2452            if 10 > max_ordinal {
2453                return Ok(());
2454            }
2455
2456            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2457            // are envelope_size bytes.
2458            let cur_offset: usize = (10 - 1) * envelope_size;
2459
2460            // Zero reserved fields.
2461            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2462
2463            // Safety:
2464            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2465            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2466            //   envelope_size bytes, there is always sufficient room.
2467            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2468                self.sound.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2469                encoder,
2470                offset + cur_offset,
2471                depth,
2472            )?;
2473
2474            _prev_end_offset = cur_offset + envelope_size;
2475            if 11 > max_ordinal {
2476                return Ok(());
2477            }
2478
2479            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2480            // are envelope_size bytes.
2481            let cur_offset: usize = (11 - 1) * envelope_size;
2482
2483            // Zero reserved fields.
2484            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2485
2486            // Safety:
2487            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2488            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2489            //   envelope_size bytes, there is always sufficient room.
2490            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<NetSpec, 32>, D>(
2491            self.networks.as_ref().map(<fidl::encoding::Vector<NetSpec, 32> as fidl::encoding::ValueTypeMarker>::borrow),
2492            encoder, offset + cur_offset, depth
2493        )?;
2494
2495            _prev_end_offset = cur_offset + envelope_size;
2496            if 12 > max_ordinal {
2497                return Ok(());
2498            }
2499
2500            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2501            // are envelope_size bytes.
2502            let cur_offset: usize = (12 - 1) * envelope_size;
2503
2504            // Zero reserved fields.
2505            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2506
2507            // Safety:
2508            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2509            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2510            //   envelope_size bytes, there is always sufficient room.
2511            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2512                self.mem.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2513                encoder,
2514                offset + cur_offset,
2515                depth,
2516            )?;
2517
2518            _prev_end_offset = cur_offset + envelope_size;
2519
2520            Ok(())
2521        }
2522    }
2523
2524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GuestDescriptor {
2525        #[inline(always)]
2526        fn new_empty() -> Self {
2527            Self::default()
2528        }
2529
2530        unsafe fn decode(
2531            &mut self,
2532            decoder: &mut fidl::encoding::Decoder<'_, D>,
2533            offset: usize,
2534            mut depth: fidl::encoding::Depth,
2535        ) -> fidl::Result<()> {
2536            decoder.debug_check_bounds::<Self>(offset);
2537            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2538                None => return Err(fidl::Error::NotNullable),
2539                Some(len) => len,
2540            };
2541            // Calling decoder.out_of_line_offset(0) is not allowed.
2542            if len == 0 {
2543                return Ok(());
2544            };
2545            depth.increment()?;
2546            let envelope_size = 8;
2547            let bytes_len = len * envelope_size;
2548            let offset = decoder.out_of_line_offset(bytes_len)?;
2549            // Decode the envelope for each type.
2550            let mut _next_ordinal_to_read = 0;
2551            let mut next_offset = offset;
2552            let end_offset = offset + bytes_len;
2553            _next_ordinal_to_read += 1;
2554            if next_offset >= end_offset {
2555                return Ok(());
2556            }
2557
2558            // Decode unknown envelopes for gaps in ordinals.
2559            while _next_ordinal_to_read < 1 {
2560                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2561                _next_ordinal_to_read += 1;
2562                next_offset += envelope_size;
2563            }
2564
2565            let next_out_of_line = decoder.next_out_of_line();
2566            let handles_before = decoder.remaining_handles();
2567            if let Some((inlined, num_bytes, num_handles)) =
2568                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2569            {
2570                let member_inline_size =
2571                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2572                if inlined != (member_inline_size <= 4) {
2573                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2574                }
2575                let inner_offset;
2576                let mut inner_depth = depth.clone();
2577                if inlined {
2578                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2579                    inner_offset = next_offset;
2580                } else {
2581                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2582                    inner_depth.increment()?;
2583                }
2584                let val_ref = self.num_cpus.get_or_insert_with(|| fidl::new_empty!(u8, D));
2585                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2586                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2587                {
2588                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2589                }
2590                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2591                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2592                }
2593            }
2594
2595            next_offset += envelope_size;
2596            _next_ordinal_to_read += 1;
2597            if next_offset >= end_offset {
2598                return Ok(());
2599            }
2600
2601            // Decode unknown envelopes for gaps in ordinals.
2602            while _next_ordinal_to_read < 2 {
2603                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2604                _next_ordinal_to_read += 1;
2605                next_offset += envelope_size;
2606            }
2607
2608            let next_out_of_line = decoder.next_out_of_line();
2609            let handles_before = decoder.remaining_handles();
2610            if let Some((inlined, num_bytes, num_handles)) =
2611                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2612            {
2613                let member_inline_size =
2614                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2615                if inlined != (member_inline_size <= 4) {
2616                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2617                }
2618                let inner_offset;
2619                let mut inner_depth = depth.clone();
2620                if inlined {
2621                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2622                    inner_offset = next_offset;
2623                } else {
2624                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2625                    inner_depth.increment()?;
2626                }
2627                let val_ref = self.guest_memory.get_or_insert_with(|| fidl::new_empty!(u64, D));
2628                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2629                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2630                {
2631                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2632                }
2633                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2634                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2635                }
2636            }
2637
2638            next_offset += envelope_size;
2639            _next_ordinal_to_read += 1;
2640            if next_offset >= end_offset {
2641                return Ok(());
2642            }
2643
2644            // Decode unknown envelopes for gaps in ordinals.
2645            while _next_ordinal_to_read < 3 {
2646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2647                _next_ordinal_to_read += 1;
2648                next_offset += envelope_size;
2649            }
2650
2651            let next_out_of_line = decoder.next_out_of_line();
2652            let handles_before = decoder.remaining_handles();
2653            if let Some((inlined, num_bytes, num_handles)) =
2654                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2655            {
2656                let member_inline_size =
2657                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2658                if inlined != (member_inline_size <= 4) {
2659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2660                }
2661                let inner_offset;
2662                let mut inner_depth = depth.clone();
2663                if inlined {
2664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2665                    inner_offset = next_offset;
2666                } else {
2667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2668                    inner_depth.increment()?;
2669                }
2670                let val_ref = self.wayland.get_or_insert_with(|| fidl::new_empty!(bool, D));
2671                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2672                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2673                {
2674                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2675                }
2676                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2677                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2678                }
2679            }
2680
2681            next_offset += envelope_size;
2682            _next_ordinal_to_read += 1;
2683            if next_offset >= end_offset {
2684                return Ok(());
2685            }
2686
2687            // Decode unknown envelopes for gaps in ordinals.
2688            while _next_ordinal_to_read < 4 {
2689                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2690                _next_ordinal_to_read += 1;
2691                next_offset += envelope_size;
2692            }
2693
2694            let next_out_of_line = decoder.next_out_of_line();
2695            let handles_before = decoder.remaining_handles();
2696            if let Some((inlined, num_bytes, num_handles)) =
2697                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2698            {
2699                let member_inline_size =
2700                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2701                if inlined != (member_inline_size <= 4) {
2702                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2703                }
2704                let inner_offset;
2705                let mut inner_depth = depth.clone();
2706                if inlined {
2707                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2708                    inner_offset = next_offset;
2709                } else {
2710                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2711                    inner_depth.increment()?;
2712                }
2713                let val_ref = self.magma.get_or_insert_with(|| fidl::new_empty!(bool, D));
2714                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2715                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2716                {
2717                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2718                }
2719                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2720                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2721                }
2722            }
2723
2724            next_offset += envelope_size;
2725            _next_ordinal_to_read += 1;
2726            if next_offset >= end_offset {
2727                return Ok(());
2728            }
2729
2730            // Decode unknown envelopes for gaps in ordinals.
2731            while _next_ordinal_to_read < 5 {
2732                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2733                _next_ordinal_to_read += 1;
2734                next_offset += envelope_size;
2735            }
2736
2737            let next_out_of_line = decoder.next_out_of_line();
2738            let handles_before = decoder.remaining_handles();
2739            if let Some((inlined, num_bytes, num_handles)) =
2740                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2741            {
2742                let member_inline_size =
2743                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2744                if inlined != (member_inline_size <= 4) {
2745                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2746                }
2747                let inner_offset;
2748                let mut inner_depth = depth.clone();
2749                if inlined {
2750                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2751                    inner_offset = next_offset;
2752                } else {
2753                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2754                    inner_depth.increment()?;
2755                }
2756                let val_ref = self.balloon.get_or_insert_with(|| fidl::new_empty!(bool, D));
2757                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2758                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2759                {
2760                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2761                }
2762                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2763                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2764                }
2765            }
2766
2767            next_offset += envelope_size;
2768            _next_ordinal_to_read += 1;
2769            if next_offset >= end_offset {
2770                return Ok(());
2771            }
2772
2773            // Decode unknown envelopes for gaps in ordinals.
2774            while _next_ordinal_to_read < 6 {
2775                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2776                _next_ordinal_to_read += 1;
2777                next_offset += envelope_size;
2778            }
2779
2780            let next_out_of_line = decoder.next_out_of_line();
2781            let handles_before = decoder.remaining_handles();
2782            if let Some((inlined, num_bytes, num_handles)) =
2783                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2784            {
2785                let member_inline_size =
2786                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2787                if inlined != (member_inline_size <= 4) {
2788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2789                }
2790                let inner_offset;
2791                let mut inner_depth = depth.clone();
2792                if inlined {
2793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2794                    inner_offset = next_offset;
2795                } else {
2796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2797                    inner_depth.increment()?;
2798                }
2799                let val_ref = self.console.get_or_insert_with(|| fidl::new_empty!(bool, D));
2800                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2802                {
2803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2804                }
2805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2807                }
2808            }
2809
2810            next_offset += envelope_size;
2811            _next_ordinal_to_read += 1;
2812            if next_offset >= end_offset {
2813                return Ok(());
2814            }
2815
2816            // Decode unknown envelopes for gaps in ordinals.
2817            while _next_ordinal_to_read < 7 {
2818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2819                _next_ordinal_to_read += 1;
2820                next_offset += envelope_size;
2821            }
2822
2823            let next_out_of_line = decoder.next_out_of_line();
2824            let handles_before = decoder.remaining_handles();
2825            if let Some((inlined, num_bytes, num_handles)) =
2826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2827            {
2828                let member_inline_size =
2829                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2830                if inlined != (member_inline_size <= 4) {
2831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2832                }
2833                let inner_offset;
2834                let mut inner_depth = depth.clone();
2835                if inlined {
2836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2837                    inner_offset = next_offset;
2838                } else {
2839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2840                    inner_depth.increment()?;
2841                }
2842                let val_ref = self.gpu.get_or_insert_with(|| fidl::new_empty!(bool, D));
2843                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2845                {
2846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2847                }
2848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2850                }
2851            }
2852
2853            next_offset += envelope_size;
2854            _next_ordinal_to_read += 1;
2855            if next_offset >= end_offset {
2856                return Ok(());
2857            }
2858
2859            // Decode unknown envelopes for gaps in ordinals.
2860            while _next_ordinal_to_read < 8 {
2861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2862                _next_ordinal_to_read += 1;
2863                next_offset += envelope_size;
2864            }
2865
2866            let next_out_of_line = decoder.next_out_of_line();
2867            let handles_before = decoder.remaining_handles();
2868            if let Some((inlined, num_bytes, num_handles)) =
2869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2870            {
2871                let member_inline_size =
2872                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2873                if inlined != (member_inline_size <= 4) {
2874                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2875                }
2876                let inner_offset;
2877                let mut inner_depth = depth.clone();
2878                if inlined {
2879                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2880                    inner_offset = next_offset;
2881                } else {
2882                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2883                    inner_depth.increment()?;
2884                }
2885                let val_ref = self.rng.get_or_insert_with(|| fidl::new_empty!(bool, D));
2886                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2888                {
2889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2890                }
2891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2893                }
2894            }
2895
2896            next_offset += envelope_size;
2897            _next_ordinal_to_read += 1;
2898            if next_offset >= end_offset {
2899                return Ok(());
2900            }
2901
2902            // Decode unknown envelopes for gaps in ordinals.
2903            while _next_ordinal_to_read < 9 {
2904                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2905                _next_ordinal_to_read += 1;
2906                next_offset += envelope_size;
2907            }
2908
2909            let next_out_of_line = decoder.next_out_of_line();
2910            let handles_before = decoder.remaining_handles();
2911            if let Some((inlined, num_bytes, num_handles)) =
2912                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2913            {
2914                let member_inline_size =
2915                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2916                if inlined != (member_inline_size <= 4) {
2917                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2918                }
2919                let inner_offset;
2920                let mut inner_depth = depth.clone();
2921                if inlined {
2922                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2923                    inner_offset = next_offset;
2924                } else {
2925                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2926                    inner_depth.increment()?;
2927                }
2928                let val_ref = self.vsock.get_or_insert_with(|| fidl::new_empty!(bool, D));
2929                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2930                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2931                {
2932                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2933                }
2934                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2935                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2936                }
2937            }
2938
2939            next_offset += envelope_size;
2940            _next_ordinal_to_read += 1;
2941            if next_offset >= end_offset {
2942                return Ok(());
2943            }
2944
2945            // Decode unknown envelopes for gaps in ordinals.
2946            while _next_ordinal_to_read < 10 {
2947                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2948                _next_ordinal_to_read += 1;
2949                next_offset += envelope_size;
2950            }
2951
2952            let next_out_of_line = decoder.next_out_of_line();
2953            let handles_before = decoder.remaining_handles();
2954            if let Some((inlined, num_bytes, num_handles)) =
2955                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2956            {
2957                let member_inline_size =
2958                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2959                if inlined != (member_inline_size <= 4) {
2960                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2961                }
2962                let inner_offset;
2963                let mut inner_depth = depth.clone();
2964                if inlined {
2965                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2966                    inner_offset = next_offset;
2967                } else {
2968                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2969                    inner_depth.increment()?;
2970                }
2971                let val_ref = self.sound.get_or_insert_with(|| fidl::new_empty!(bool, D));
2972                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2973                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2974                {
2975                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2976                }
2977                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2978                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2979                }
2980            }
2981
2982            next_offset += envelope_size;
2983            _next_ordinal_to_read += 1;
2984            if next_offset >= end_offset {
2985                return Ok(());
2986            }
2987
2988            // Decode unknown envelopes for gaps in ordinals.
2989            while _next_ordinal_to_read < 11 {
2990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2991                _next_ordinal_to_read += 1;
2992                next_offset += envelope_size;
2993            }
2994
2995            let next_out_of_line = decoder.next_out_of_line();
2996            let handles_before = decoder.remaining_handles();
2997            if let Some((inlined, num_bytes, num_handles)) =
2998                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2999            {
3000                let member_inline_size = <fidl::encoding::Vector<NetSpec, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3001                if inlined != (member_inline_size <= 4) {
3002                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3003                }
3004                let inner_offset;
3005                let mut inner_depth = depth.clone();
3006                if inlined {
3007                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3008                    inner_offset = next_offset;
3009                } else {
3010                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3011                    inner_depth.increment()?;
3012                }
3013                let val_ref = self.networks.get_or_insert_with(
3014                    || fidl::new_empty!(fidl::encoding::Vector<NetSpec, 32>, D),
3015                );
3016                fidl::decode!(fidl::encoding::Vector<NetSpec, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3017                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3018                {
3019                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3020                }
3021                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3022                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3023                }
3024            }
3025
3026            next_offset += envelope_size;
3027            _next_ordinal_to_read += 1;
3028            if next_offset >= end_offset {
3029                return Ok(());
3030            }
3031
3032            // Decode unknown envelopes for gaps in ordinals.
3033            while _next_ordinal_to_read < 12 {
3034                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3035                _next_ordinal_to_read += 1;
3036                next_offset += envelope_size;
3037            }
3038
3039            let next_out_of_line = decoder.next_out_of_line();
3040            let handles_before = decoder.remaining_handles();
3041            if let Some((inlined, num_bytes, num_handles)) =
3042                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3043            {
3044                let member_inline_size =
3045                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3046                if inlined != (member_inline_size <= 4) {
3047                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3048                }
3049                let inner_offset;
3050                let mut inner_depth = depth.clone();
3051                if inlined {
3052                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3053                    inner_offset = next_offset;
3054                } else {
3055                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3056                    inner_depth.increment()?;
3057                }
3058                let val_ref = self.mem.get_or_insert_with(|| fidl::new_empty!(bool, D));
3059                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3060                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3061                {
3062                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3063                }
3064                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3065                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3066                }
3067            }
3068
3069            next_offset += envelope_size;
3070
3071            // Decode the remaining unknown envelopes.
3072            while next_offset < end_offset {
3073                _next_ordinal_to_read += 1;
3074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3075                next_offset += envelope_size;
3076            }
3077
3078            Ok(())
3079        }
3080    }
3081
3082    impl GuestInfo {
3083        #[inline(always)]
3084        fn max_ordinal_present(&self) -> u64 {
3085            if let Some(_) = self.detected_problems {
3086                return 5;
3087            }
3088            if let Some(_) = self.stop_error {
3089                return 4;
3090            }
3091            if let Some(_) = self.guest_descriptor {
3092                return 3;
3093            }
3094            if let Some(_) = self.uptime {
3095                return 2;
3096            }
3097            if let Some(_) = self.guest_status {
3098                return 1;
3099            }
3100            0
3101        }
3102    }
3103
3104    impl fidl::encoding::ValueTypeMarker for GuestInfo {
3105        type Borrowed<'a> = &'a Self;
3106        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3107            value
3108        }
3109    }
3110
3111    unsafe impl fidl::encoding::TypeMarker for GuestInfo {
3112        type Owned = Self;
3113
3114        #[inline(always)]
3115        fn inline_align(_context: fidl::encoding::Context) -> usize {
3116            8
3117        }
3118
3119        #[inline(always)]
3120        fn inline_size(_context: fidl::encoding::Context) -> usize {
3121            16
3122        }
3123    }
3124
3125    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GuestInfo, D>
3126        for &GuestInfo
3127    {
3128        unsafe fn encode(
3129            self,
3130            encoder: &mut fidl::encoding::Encoder<'_, D>,
3131            offset: usize,
3132            mut depth: fidl::encoding::Depth,
3133        ) -> fidl::Result<()> {
3134            encoder.debug_check_bounds::<GuestInfo>(offset);
3135            // Vector header
3136            let max_ordinal: u64 = self.max_ordinal_present();
3137            encoder.write_num(max_ordinal, offset);
3138            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3139            // Calling encoder.out_of_line_offset(0) is not allowed.
3140            if max_ordinal == 0 {
3141                return Ok(());
3142            }
3143            depth.increment()?;
3144            let envelope_size = 8;
3145            let bytes_len = max_ordinal as usize * envelope_size;
3146            #[allow(unused_variables)]
3147            let offset = encoder.out_of_line_offset(bytes_len);
3148            let mut _prev_end_offset: usize = 0;
3149            if 1 > max_ordinal {
3150                return Ok(());
3151            }
3152
3153            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3154            // are envelope_size bytes.
3155            let cur_offset: usize = (1 - 1) * envelope_size;
3156
3157            // Zero reserved fields.
3158            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3159
3160            // Safety:
3161            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3162            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3163            //   envelope_size bytes, there is always sufficient room.
3164            fidl::encoding::encode_in_envelope_optional::<GuestStatus, D>(
3165                self.guest_status
3166                    .as_ref()
3167                    .map(<GuestStatus as fidl::encoding::ValueTypeMarker>::borrow),
3168                encoder,
3169                offset + cur_offset,
3170                depth,
3171            )?;
3172
3173            _prev_end_offset = cur_offset + envelope_size;
3174            if 2 > max_ordinal {
3175                return Ok(());
3176            }
3177
3178            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3179            // are envelope_size bytes.
3180            let cur_offset: usize = (2 - 1) * envelope_size;
3181
3182            // Zero reserved fields.
3183            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3184
3185            // Safety:
3186            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3187            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3188            //   envelope_size bytes, there is always sufficient room.
3189            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3190                self.uptime.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3191                encoder,
3192                offset + cur_offset,
3193                depth,
3194            )?;
3195
3196            _prev_end_offset = cur_offset + envelope_size;
3197            if 3 > max_ordinal {
3198                return Ok(());
3199            }
3200
3201            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3202            // are envelope_size bytes.
3203            let cur_offset: usize = (3 - 1) * envelope_size;
3204
3205            // Zero reserved fields.
3206            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3207
3208            // Safety:
3209            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3210            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3211            //   envelope_size bytes, there is always sufficient room.
3212            fidl::encoding::encode_in_envelope_optional::<GuestDescriptor, D>(
3213                self.guest_descriptor
3214                    .as_ref()
3215                    .map(<GuestDescriptor as fidl::encoding::ValueTypeMarker>::borrow),
3216                encoder,
3217                offset + cur_offset,
3218                depth,
3219            )?;
3220
3221            _prev_end_offset = cur_offset + envelope_size;
3222            if 4 > max_ordinal {
3223                return Ok(());
3224            }
3225
3226            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3227            // are envelope_size bytes.
3228            let cur_offset: usize = (4 - 1) * envelope_size;
3229
3230            // Zero reserved fields.
3231            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3232
3233            // Safety:
3234            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3235            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3236            //   envelope_size bytes, there is always sufficient room.
3237            fidl::encoding::encode_in_envelope_optional::<GuestError, D>(
3238                self.stop_error
3239                    .as_ref()
3240                    .map(<GuestError as fidl::encoding::ValueTypeMarker>::borrow),
3241                encoder,
3242                offset + cur_offset,
3243                depth,
3244            )?;
3245
3246            _prev_end_offset = cur_offset + envelope_size;
3247            if 5 > max_ordinal {
3248                return Ok(());
3249            }
3250
3251            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3252            // are envelope_size bytes.
3253            let cur_offset: usize = (5 - 1) * envelope_size;
3254
3255            // Zero reserved fields.
3256            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3257
3258            // Safety:
3259            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3260            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3261            //   envelope_size bytes, there is always sufficient room.
3262            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::UnboundedString, 8>, D>(
3263            self.detected_problems.as_ref().map(<fidl::encoding::Vector<fidl::encoding::UnboundedString, 8> as fidl::encoding::ValueTypeMarker>::borrow),
3264            encoder, offset + cur_offset, depth
3265        )?;
3266
3267            _prev_end_offset = cur_offset + envelope_size;
3268
3269            Ok(())
3270        }
3271    }
3272
3273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GuestInfo {
3274        #[inline(always)]
3275        fn new_empty() -> Self {
3276            Self::default()
3277        }
3278
3279        unsafe fn decode(
3280            &mut self,
3281            decoder: &mut fidl::encoding::Decoder<'_, D>,
3282            offset: usize,
3283            mut depth: fidl::encoding::Depth,
3284        ) -> fidl::Result<()> {
3285            decoder.debug_check_bounds::<Self>(offset);
3286            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3287                None => return Err(fidl::Error::NotNullable),
3288                Some(len) => len,
3289            };
3290            // Calling decoder.out_of_line_offset(0) is not allowed.
3291            if len == 0 {
3292                return Ok(());
3293            };
3294            depth.increment()?;
3295            let envelope_size = 8;
3296            let bytes_len = len * envelope_size;
3297            let offset = decoder.out_of_line_offset(bytes_len)?;
3298            // Decode the envelope for each type.
3299            let mut _next_ordinal_to_read = 0;
3300            let mut next_offset = offset;
3301            let end_offset = offset + bytes_len;
3302            _next_ordinal_to_read += 1;
3303            if next_offset >= end_offset {
3304                return Ok(());
3305            }
3306
3307            // Decode unknown envelopes for gaps in ordinals.
3308            while _next_ordinal_to_read < 1 {
3309                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3310                _next_ordinal_to_read += 1;
3311                next_offset += envelope_size;
3312            }
3313
3314            let next_out_of_line = decoder.next_out_of_line();
3315            let handles_before = decoder.remaining_handles();
3316            if let Some((inlined, num_bytes, num_handles)) =
3317                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3318            {
3319                let member_inline_size =
3320                    <GuestStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3321                if inlined != (member_inline_size <= 4) {
3322                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3323                }
3324                let inner_offset;
3325                let mut inner_depth = depth.clone();
3326                if inlined {
3327                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3328                    inner_offset = next_offset;
3329                } else {
3330                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3331                    inner_depth.increment()?;
3332                }
3333                let val_ref =
3334                    self.guest_status.get_or_insert_with(|| fidl::new_empty!(GuestStatus, D));
3335                fidl::decode!(GuestStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
3336                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3337                {
3338                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3339                }
3340                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3341                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3342                }
3343            }
3344
3345            next_offset += envelope_size;
3346            _next_ordinal_to_read += 1;
3347            if next_offset >= end_offset {
3348                return Ok(());
3349            }
3350
3351            // Decode unknown envelopes for gaps in ordinals.
3352            while _next_ordinal_to_read < 2 {
3353                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3354                _next_ordinal_to_read += 1;
3355                next_offset += envelope_size;
3356            }
3357
3358            let next_out_of_line = decoder.next_out_of_line();
3359            let handles_before = decoder.remaining_handles();
3360            if let Some((inlined, num_bytes, num_handles)) =
3361                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3362            {
3363                let member_inline_size =
3364                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3365                if inlined != (member_inline_size <= 4) {
3366                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3367                }
3368                let inner_offset;
3369                let mut inner_depth = depth.clone();
3370                if inlined {
3371                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3372                    inner_offset = next_offset;
3373                } else {
3374                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3375                    inner_depth.increment()?;
3376                }
3377                let val_ref = self.uptime.get_or_insert_with(|| fidl::new_empty!(i64, D));
3378                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3379                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3380                {
3381                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3382                }
3383                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3384                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3385                }
3386            }
3387
3388            next_offset += envelope_size;
3389            _next_ordinal_to_read += 1;
3390            if next_offset >= end_offset {
3391                return Ok(());
3392            }
3393
3394            // Decode unknown envelopes for gaps in ordinals.
3395            while _next_ordinal_to_read < 3 {
3396                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3397                _next_ordinal_to_read += 1;
3398                next_offset += envelope_size;
3399            }
3400
3401            let next_out_of_line = decoder.next_out_of_line();
3402            let handles_before = decoder.remaining_handles();
3403            if let Some((inlined, num_bytes, num_handles)) =
3404                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3405            {
3406                let member_inline_size =
3407                    <GuestDescriptor as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3408                if inlined != (member_inline_size <= 4) {
3409                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3410                }
3411                let inner_offset;
3412                let mut inner_depth = depth.clone();
3413                if inlined {
3414                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3415                    inner_offset = next_offset;
3416                } else {
3417                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3418                    inner_depth.increment()?;
3419                }
3420                let val_ref = self
3421                    .guest_descriptor
3422                    .get_or_insert_with(|| fidl::new_empty!(GuestDescriptor, D));
3423                fidl::decode!(GuestDescriptor, D, val_ref, decoder, inner_offset, inner_depth)?;
3424                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3425                {
3426                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3427                }
3428                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3429                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3430                }
3431            }
3432
3433            next_offset += envelope_size;
3434            _next_ordinal_to_read += 1;
3435            if next_offset >= end_offset {
3436                return Ok(());
3437            }
3438
3439            // Decode unknown envelopes for gaps in ordinals.
3440            while _next_ordinal_to_read < 4 {
3441                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3442                _next_ordinal_to_read += 1;
3443                next_offset += envelope_size;
3444            }
3445
3446            let next_out_of_line = decoder.next_out_of_line();
3447            let handles_before = decoder.remaining_handles();
3448            if let Some((inlined, num_bytes, num_handles)) =
3449                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3450            {
3451                let member_inline_size =
3452                    <GuestError as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3453                if inlined != (member_inline_size <= 4) {
3454                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3455                }
3456                let inner_offset;
3457                let mut inner_depth = depth.clone();
3458                if inlined {
3459                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3460                    inner_offset = next_offset;
3461                } else {
3462                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3463                    inner_depth.increment()?;
3464                }
3465                let val_ref =
3466                    self.stop_error.get_or_insert_with(|| fidl::new_empty!(GuestError, D));
3467                fidl::decode!(GuestError, D, val_ref, decoder, inner_offset, inner_depth)?;
3468                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3469                {
3470                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3471                }
3472                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3473                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3474                }
3475            }
3476
3477            next_offset += envelope_size;
3478            _next_ordinal_to_read += 1;
3479            if next_offset >= end_offset {
3480                return Ok(());
3481            }
3482
3483            // Decode unknown envelopes for gaps in ordinals.
3484            while _next_ordinal_to_read < 5 {
3485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3486                _next_ordinal_to_read += 1;
3487                next_offset += envelope_size;
3488            }
3489
3490            let next_out_of_line = decoder.next_out_of_line();
3491            let handles_before = decoder.remaining_handles();
3492            if let Some((inlined, num_bytes, num_handles)) =
3493                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3494            {
3495                let member_inline_size = <fidl::encoding::Vector<fidl::encoding::UnboundedString, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3496                if inlined != (member_inline_size <= 4) {
3497                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3498                }
3499                let inner_offset;
3500                let mut inner_depth = depth.clone();
3501                if inlined {
3502                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3503                    inner_offset = next_offset;
3504                } else {
3505                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3506                    inner_depth.increment()?;
3507                }
3508                let val_ref =
3509                self.detected_problems.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 8>, D));
3510                fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
3511                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3512                {
3513                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3514                }
3515                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3516                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3517                }
3518            }
3519
3520            next_offset += envelope_size;
3521
3522            // Decode the remaining unknown envelopes.
3523            while next_offset < end_offset {
3524                _next_ordinal_to_read += 1;
3525                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3526                next_offset += envelope_size;
3527            }
3528
3529            Ok(())
3530        }
3531    }
3532
3533    impl LinuxGuestInfo {
3534        #[inline(always)]
3535        fn max_ordinal_present(&self) -> u64 {
3536            if let Some(_) = self.failure_reason {
3537                return 4;
3538            }
3539            if let Some(_) = self.download_percent {
3540                return 3;
3541            }
3542            if let Some(_) = self.container_status {
3543                return 2;
3544            }
3545            if let Some(_) = self.cid {
3546                return 1;
3547            }
3548            0
3549        }
3550    }
3551
3552    impl fidl::encoding::ValueTypeMarker for LinuxGuestInfo {
3553        type Borrowed<'a> = &'a Self;
3554        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3555            value
3556        }
3557    }
3558
3559    unsafe impl fidl::encoding::TypeMarker for LinuxGuestInfo {
3560        type Owned = Self;
3561
3562        #[inline(always)]
3563        fn inline_align(_context: fidl::encoding::Context) -> usize {
3564            8
3565        }
3566
3567        #[inline(always)]
3568        fn inline_size(_context: fidl::encoding::Context) -> usize {
3569            16
3570        }
3571    }
3572
3573    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LinuxGuestInfo, D>
3574        for &LinuxGuestInfo
3575    {
3576        unsafe fn encode(
3577            self,
3578            encoder: &mut fidl::encoding::Encoder<'_, D>,
3579            offset: usize,
3580            mut depth: fidl::encoding::Depth,
3581        ) -> fidl::Result<()> {
3582            encoder.debug_check_bounds::<LinuxGuestInfo>(offset);
3583            // Vector header
3584            let max_ordinal: u64 = self.max_ordinal_present();
3585            encoder.write_num(max_ordinal, offset);
3586            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3587            // Calling encoder.out_of_line_offset(0) is not allowed.
3588            if max_ordinal == 0 {
3589                return Ok(());
3590            }
3591            depth.increment()?;
3592            let envelope_size = 8;
3593            let bytes_len = max_ordinal as usize * envelope_size;
3594            #[allow(unused_variables)]
3595            let offset = encoder.out_of_line_offset(bytes_len);
3596            let mut _prev_end_offset: usize = 0;
3597            if 1 > max_ordinal {
3598                return Ok(());
3599            }
3600
3601            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3602            // are envelope_size bytes.
3603            let cur_offset: usize = (1 - 1) * envelope_size;
3604
3605            // Zero reserved fields.
3606            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3607
3608            // Safety:
3609            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3610            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3611            //   envelope_size bytes, there is always sufficient room.
3612            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3613                self.cid.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3614                encoder,
3615                offset + cur_offset,
3616                depth,
3617            )?;
3618
3619            _prev_end_offset = cur_offset + envelope_size;
3620            if 2 > max_ordinal {
3621                return Ok(());
3622            }
3623
3624            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3625            // are envelope_size bytes.
3626            let cur_offset: usize = (2 - 1) * envelope_size;
3627
3628            // Zero reserved fields.
3629            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3630
3631            // Safety:
3632            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3633            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3634            //   envelope_size bytes, there is always sufficient room.
3635            fidl::encoding::encode_in_envelope_optional::<ContainerStatus, D>(
3636                self.container_status
3637                    .as_ref()
3638                    .map(<ContainerStatus as fidl::encoding::ValueTypeMarker>::borrow),
3639                encoder,
3640                offset + cur_offset,
3641                depth,
3642            )?;
3643
3644            _prev_end_offset = cur_offset + envelope_size;
3645            if 3 > max_ordinal {
3646                return Ok(());
3647            }
3648
3649            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3650            // are envelope_size bytes.
3651            let cur_offset: usize = (3 - 1) * envelope_size;
3652
3653            // Zero reserved fields.
3654            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3655
3656            // Safety:
3657            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3658            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3659            //   envelope_size bytes, there is always sufficient room.
3660            fidl::encoding::encode_in_envelope_optional::<i32, D>(
3661                self.download_percent
3662                    .as_ref()
3663                    .map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3664                encoder,
3665                offset + cur_offset,
3666                depth,
3667            )?;
3668
3669            _prev_end_offset = cur_offset + envelope_size;
3670            if 4 > max_ordinal {
3671                return Ok(());
3672            }
3673
3674            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3675            // are envelope_size bytes.
3676            let cur_offset: usize = (4 - 1) * envelope_size;
3677
3678            // Zero reserved fields.
3679            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3680
3681            // Safety:
3682            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3683            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3684            //   envelope_size bytes, there is always sufficient room.
3685            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3686                self.failure_reason.as_ref().map(
3687                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3688                ),
3689                encoder,
3690                offset + cur_offset,
3691                depth,
3692            )?;
3693
3694            _prev_end_offset = cur_offset + envelope_size;
3695
3696            Ok(())
3697        }
3698    }
3699
3700    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LinuxGuestInfo {
3701        #[inline(always)]
3702        fn new_empty() -> Self {
3703            Self::default()
3704        }
3705
3706        unsafe fn decode(
3707            &mut self,
3708            decoder: &mut fidl::encoding::Decoder<'_, D>,
3709            offset: usize,
3710            mut depth: fidl::encoding::Depth,
3711        ) -> fidl::Result<()> {
3712            decoder.debug_check_bounds::<Self>(offset);
3713            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3714                None => return Err(fidl::Error::NotNullable),
3715                Some(len) => len,
3716            };
3717            // Calling decoder.out_of_line_offset(0) is not allowed.
3718            if len == 0 {
3719                return Ok(());
3720            };
3721            depth.increment()?;
3722            let envelope_size = 8;
3723            let bytes_len = len * envelope_size;
3724            let offset = decoder.out_of_line_offset(bytes_len)?;
3725            // Decode the envelope for each type.
3726            let mut _next_ordinal_to_read = 0;
3727            let mut next_offset = offset;
3728            let end_offset = offset + bytes_len;
3729            _next_ordinal_to_read += 1;
3730            if next_offset >= end_offset {
3731                return Ok(());
3732            }
3733
3734            // Decode unknown envelopes for gaps in ordinals.
3735            while _next_ordinal_to_read < 1 {
3736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3737                _next_ordinal_to_read += 1;
3738                next_offset += envelope_size;
3739            }
3740
3741            let next_out_of_line = decoder.next_out_of_line();
3742            let handles_before = decoder.remaining_handles();
3743            if let Some((inlined, num_bytes, num_handles)) =
3744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3745            {
3746                let member_inline_size =
3747                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3748                if inlined != (member_inline_size <= 4) {
3749                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3750                }
3751                let inner_offset;
3752                let mut inner_depth = depth.clone();
3753                if inlined {
3754                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3755                    inner_offset = next_offset;
3756                } else {
3757                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3758                    inner_depth.increment()?;
3759                }
3760                let val_ref = self.cid.get_or_insert_with(|| fidl::new_empty!(u32, D));
3761                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3762                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3763                {
3764                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3765                }
3766                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3767                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3768                }
3769            }
3770
3771            next_offset += envelope_size;
3772            _next_ordinal_to_read += 1;
3773            if next_offset >= end_offset {
3774                return Ok(());
3775            }
3776
3777            // Decode unknown envelopes for gaps in ordinals.
3778            while _next_ordinal_to_read < 2 {
3779                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3780                _next_ordinal_to_read += 1;
3781                next_offset += envelope_size;
3782            }
3783
3784            let next_out_of_line = decoder.next_out_of_line();
3785            let handles_before = decoder.remaining_handles();
3786            if let Some((inlined, num_bytes, num_handles)) =
3787                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3788            {
3789                let member_inline_size =
3790                    <ContainerStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3791                if inlined != (member_inline_size <= 4) {
3792                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3793                }
3794                let inner_offset;
3795                let mut inner_depth = depth.clone();
3796                if inlined {
3797                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3798                    inner_offset = next_offset;
3799                } else {
3800                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3801                    inner_depth.increment()?;
3802                }
3803                let val_ref = self
3804                    .container_status
3805                    .get_or_insert_with(|| fidl::new_empty!(ContainerStatus, D));
3806                fidl::decode!(ContainerStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
3807                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3808                {
3809                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3810                }
3811                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3812                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3813                }
3814            }
3815
3816            next_offset += envelope_size;
3817            _next_ordinal_to_read += 1;
3818            if next_offset >= end_offset {
3819                return Ok(());
3820            }
3821
3822            // Decode unknown envelopes for gaps in ordinals.
3823            while _next_ordinal_to_read < 3 {
3824                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3825                _next_ordinal_to_read += 1;
3826                next_offset += envelope_size;
3827            }
3828
3829            let next_out_of_line = decoder.next_out_of_line();
3830            let handles_before = decoder.remaining_handles();
3831            if let Some((inlined, num_bytes, num_handles)) =
3832                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3833            {
3834                let member_inline_size =
3835                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3836                if inlined != (member_inline_size <= 4) {
3837                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3838                }
3839                let inner_offset;
3840                let mut inner_depth = depth.clone();
3841                if inlined {
3842                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3843                    inner_offset = next_offset;
3844                } else {
3845                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3846                    inner_depth.increment()?;
3847                }
3848                let val_ref = self.download_percent.get_or_insert_with(|| fidl::new_empty!(i32, D));
3849                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3850                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3851                {
3852                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3853                }
3854                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3855                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3856                }
3857            }
3858
3859            next_offset += envelope_size;
3860            _next_ordinal_to_read += 1;
3861            if next_offset >= end_offset {
3862                return Ok(());
3863            }
3864
3865            // Decode unknown envelopes for gaps in ordinals.
3866            while _next_ordinal_to_read < 4 {
3867                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3868                _next_ordinal_to_read += 1;
3869                next_offset += envelope_size;
3870            }
3871
3872            let next_out_of_line = decoder.next_out_of_line();
3873            let handles_before = decoder.remaining_handles();
3874            if let Some((inlined, num_bytes, num_handles)) =
3875                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3876            {
3877                let member_inline_size =
3878                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3879                        decoder.context,
3880                    );
3881                if inlined != (member_inline_size <= 4) {
3882                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3883                }
3884                let inner_offset;
3885                let mut inner_depth = depth.clone();
3886                if inlined {
3887                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3888                    inner_offset = next_offset;
3889                } else {
3890                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3891                    inner_depth.increment()?;
3892                }
3893                let val_ref = self
3894                    .failure_reason
3895                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3896                fidl::decode!(
3897                    fidl::encoding::UnboundedString,
3898                    D,
3899                    val_ref,
3900                    decoder,
3901                    inner_offset,
3902                    inner_depth
3903                )?;
3904                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3905                {
3906                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3907                }
3908                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3909                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3910                }
3911            }
3912
3913            next_offset += envelope_size;
3914
3915            // Decode the remaining unknown envelopes.
3916            while next_offset < end_offset {
3917                _next_ordinal_to_read += 1;
3918                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3919                next_offset += envelope_size;
3920            }
3921
3922            Ok(())
3923        }
3924    }
3925}