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