1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const DEFAULT_GUEST_CID: u32 = 3;
13
14pub 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 ReadWrite = 0,
30 ReadOnly = 1,
32 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#[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 InternalError = 1,
94 DeviceNotPresent = 2,
96 BadConfig = 3,
98 GuestInitializationFailure = 4,
101 DeviceInitializationFailure = 5,
103 DeviceStartFailure = 6,
105 DeviceMemoryOverlap = 7,
107 FailedServiceConnect = 8,
109 DuplicatePublicServices = 9,
111 KernelLoadFailure = 10,
113 VcpuStartFailure = 11,
115 VcpuRuntimeFailure = 12,
117 NotCreated = 13,
119 AlreadyRunning = 14,
122 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 BadConfig = 1,
161 AlreadyRunning = 2,
163 NotRunning = 3,
165 StartFailure = 4,
167 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 NotStarted = 1,
196 Starting = 2,
198 Running = 3,
200 Stopping = 4,
203 Stopped = 5,
206 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#[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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
322#[repr(C)]
323pub struct MagmaDevice {
324 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#[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#[derive(Clone, Debug, PartialEq)]
365pub struct NetSpec {
366 pub mac_address: fidl_fuchsia_net__common::MacAddress,
368 pub enable_bridge: bool,
370}
371
372impl fidl::Persistable for NetSpec {}
373
374#[derive(Clone, Debug, Default, PartialEq)]
377pub struct GuestDescriptor {
378 pub num_cpus: Option<u8>,
380 pub guest_memory: Option<u64>,
382 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 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 pub guest_status: Option<GuestStatus>,
405 pub uptime: Option<i64>,
407 pub guest_descriptor: Option<GuestDescriptor>,
409 pub stop_error: Option<GuestError>,
411 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#[derive(Clone, Debug, Default, PartialEq)]
425pub struct LinuxGuestInfo {
426 pub cid: Option<u32>,
428 pub container_status: Option<ContainerStatus>,
430 pub download_percent: Option<i32>,
433 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 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 }
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 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 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 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 unsafe {
1084 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1085 (ptr as *mut u64).write_unaligned(0);
1086 }
1087 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 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 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 }
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 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 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 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 }
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 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 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 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 }
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 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 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 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 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 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 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 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 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 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 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 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 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1768 (buf_ptr as *mut MagmaDevice).write_unaligned((self as *const MagmaDevice).read());
1769 }
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 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 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 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 }
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 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 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 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 }
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 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 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 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2063 (buf_ptr as *mut MemStat).write_unaligned((self as *const MemStat).read());
2064 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 unsafe {
2090 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2091 (ptr as *mut u64).write_unaligned(0);
2092 }
2093 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
2322
2323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2325
2326 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 let cur_offset: usize = (2 - 1) * envelope_size;
2345
2346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2348
2349 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 let cur_offset: usize = (3 - 1) * envelope_size;
2368
2369 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2371
2372 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 let cur_offset: usize = (4 - 1) * envelope_size;
2391
2392 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2394
2395 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 let cur_offset: usize = (5 - 1) * envelope_size;
2414
2415 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2417
2418 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 let cur_offset: usize = (6 - 1) * envelope_size;
2437
2438 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2440
2441 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 let cur_offset: usize = (7 - 1) * envelope_size;
2460
2461 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2463
2464 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 let cur_offset: usize = (8 - 1) * envelope_size;
2483
2484 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2486
2487 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 let cur_offset: usize = (9 - 1) * envelope_size;
2506
2507 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2509
2510 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 let cur_offset: usize = (10 - 1) * envelope_size;
2529
2530 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2532
2533 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 let cur_offset: usize = (11 - 1) * envelope_size;
2552
2553 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2555
2556 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 let cur_offset: usize = (12 - 1) * envelope_size;
2573
2574 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2576
2577 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
3226
3227 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3229
3230 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 let cur_offset: usize = (2 - 1) * envelope_size;
3251
3252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3254
3255 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 let cur_offset: usize = (3 - 1) * envelope_size;
3274
3275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3277
3278 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 let cur_offset: usize = (4 - 1) * envelope_size;
3299
3300 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3302
3303 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 let cur_offset: usize = (5 - 1) * envelope_size;
3324
3325 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3327
3328 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 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 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
3674
3675 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3677
3678 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 let cur_offset: usize = (2 - 1) * envelope_size;
3697
3698 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3700
3701 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 let cur_offset: usize = (3 - 1) * envelope_size;
3722
3723 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3725
3726 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 let cur_offset: usize = (4 - 1) * envelope_size;
3747
3748 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3750
3751 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 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 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 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 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 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 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 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}