fidl_fuchsia_gpu_magma__common/
fidl_fuchsia_gpu_magma__common.rs

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