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