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