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