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