1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const CPU_USAGE_READ: u32 = 1;
12
13pub const CPU_USAGE_READ_OFTEN: u32 = 2;
14
15pub const CPU_USAGE_WRITE: u32 = 4;
16
17pub const CPU_USAGE_WRITE_OFTEN: u32 = 8;
18
19pub const DISPLAY_USAGE_CURSOR: u32 = 2;
20
21pub const DISPLAY_USAGE_LAYER: u32 = 1;
22
23pub const MAX_CLIENT_NAME_LENGTH: i32 = 256;
27
28pub const MAX_COUNT_BUFFER_COLLECTION_CONSTRAINTS_IMAGE_FORMAT_CONSTRAINTS: u32 = 64;
31
32pub const MAX_COUNT_BUFFER_COLLECTION_INFO_BUFFERS: u32 = 128;
35
36pub const MAX_COUNT_BUFFER_MEMORY_CONSTRAINTS_PERMITTED_HEAPS: u32 = 64;
39
40pub const MAX_COUNT_CREATE_CHILDREN: i32 = 64;
51
52pub const MAX_COUNT_DUPLICATES: u32 = 64;
53
54pub const MAX_COUNT_IMAGE_FORMAT_CONSTRAINTS_COLOR_SPACES: u32 = 32;
56
57pub const MAX_COUNT_PIXEL_FORMAT_AND_MODIFIERS: u32 = 64;
60
61pub const MAX_HEAPS_COUNT: u32 = 32;
62
63pub const MAX_RANGES_COUNT: u32 = 128;
64
65pub const NONE_USAGE: u32 = 1;
66
67pub const NONE_USAGE_PERMIT_ALLOCATION: u32 = 2;
68
69pub const VIDEO_USAGE_CAPTURE: u32 = 8;
70
71pub const VIDEO_USAGE_DECRYPTOR_OUTPUT: u32 = 16;
72
73pub const VIDEO_USAGE_HW_DECODER: u32 = 1;
74
75pub const VIDEO_USAGE_HW_DECODER_INTERNAL: u32 = 32;
76
77pub const VIDEO_USAGE_HW_ENCODER: u32 = 2;
78
79pub const VULKAN_BUFFER_USAGE_INDEX_BUFFER: u32 = 4194304;
80
81pub const VULKAN_BUFFER_USAGE_INDIRECT_BUFFER: u32 = 16777216;
82
83pub const VULKAN_BUFFER_USAGE_STORAGE_BUFFER: u32 = 2097152;
84
85pub const VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER: u32 = 524288;
86
87pub const VULKAN_BUFFER_USAGE_TRANSFER_DST: u32 = 131072;
88
89pub const VULKAN_BUFFER_USAGE_TRANSFER_SRC: u32 = 65536;
90
91pub const VULKAN_BUFFER_USAGE_UNIFORM_BUFFER: u32 = 1048576;
92
93pub const VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER: u32 = 262144;
94
95pub const VULKAN_BUFFER_USAGE_VERTEX_BUFFER: u32 = 8388608;
96
97pub const VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT: u32 = 16;
98
99pub const VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT: u32 = 128;
100
101pub const VULKAN_IMAGE_USAGE_SAMPLED: u32 = 4;
102
103pub const VULKAN_IMAGE_USAGE_STENCIL_ATTACHMENT: u32 = 32;
104
105pub const VULKAN_IMAGE_USAGE_STORAGE: u32 = 8;
106
107pub const VULKAN_IMAGE_USAGE_TRANSFER_DST: u32 = 2;
108
109pub const VULKAN_IMAGE_USAGE_TRANSFER_SRC: u32 = 1;
110
111pub const VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT: u32 = 64;
112
113#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
133pub enum CoherencyDomain {
134 Cpu,
135 Ram,
136 Inaccessible,
137 #[doc(hidden)]
138 __SourceBreaking {
139 unknown_ordinal: u32,
140 },
141}
142
143#[macro_export]
145macro_rules! CoherencyDomainUnknown {
146 () => {
147 _
148 };
149}
150
151impl CoherencyDomain {
152 #[inline]
153 pub fn from_primitive(prim: u32) -> Option<Self> {
154 match prim {
155 0 => Some(Self::Cpu),
156 1 => Some(Self::Ram),
157 2 => Some(Self::Inaccessible),
158 _ => None,
159 }
160 }
161
162 #[inline]
163 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
164 match prim {
165 0 => Self::Cpu,
166 1 => Self::Ram,
167 2 => Self::Inaccessible,
168 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
169 }
170 }
171
172 #[inline]
173 pub fn unknown() -> Self {
174 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
175 }
176
177 #[inline]
178 pub const fn into_primitive(self) -> u32 {
179 match self {
180 Self::Cpu => 0,
181 Self::Ram => 1,
182 Self::Inaccessible => 2,
183 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
184 }
185 }
186
187 #[inline]
188 pub fn is_unknown(&self) -> bool {
189 match self {
190 Self::__SourceBreaking { unknown_ordinal: _ } => true,
191 _ => false,
192 }
193 }
194}
195
196#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
202pub enum Error {
203 Invalid,
209 Unspecified,
233 ProtocolDeviation,
239 NotFound,
241 HandleAccessDenied,
243 NoMemory,
250 ConstraintsIntersectionEmpty,
263 Pending,
267 TooManyGroupChildCombinations,
271 #[doc(hidden)]
272 __SourceBreaking { unknown_ordinal: u32 },
273}
274
275#[macro_export]
277macro_rules! ErrorUnknown {
278 () => {
279 _
280 };
281}
282
283impl Error {
284 #[inline]
285 pub fn from_primitive(prim: u32) -> Option<Self> {
286 match prim {
287 0 => Some(Self::Invalid),
288 1 => Some(Self::Unspecified),
289 2 => Some(Self::ProtocolDeviation),
290 3 => Some(Self::NotFound),
291 4 => Some(Self::HandleAccessDenied),
292 5 => Some(Self::NoMemory),
293 6 => Some(Self::ConstraintsIntersectionEmpty),
294 7 => Some(Self::Pending),
295 8 => Some(Self::TooManyGroupChildCombinations),
296 _ => None,
297 }
298 }
299
300 #[inline]
301 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
302 match prim {
303 0 => Self::Invalid,
304 1 => Self::Unspecified,
305 2 => Self::ProtocolDeviation,
306 3 => Self::NotFound,
307 4 => Self::HandleAccessDenied,
308 5 => Self::NoMemory,
309 6 => Self::ConstraintsIntersectionEmpty,
310 7 => Self::Pending,
311 8 => Self::TooManyGroupChildCombinations,
312 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
313 }
314 }
315
316 #[inline]
317 pub fn unknown() -> Self {
318 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
319 }
320
321 #[inline]
322 pub const fn into_primitive(self) -> u32 {
323 match self {
324 Self::Invalid => 0,
325 Self::Unspecified => 1,
326 Self::ProtocolDeviation => 2,
327 Self::NotFound => 3,
328 Self::HandleAccessDenied => 4,
329 Self::NoMemory => 5,
330 Self::ConstraintsIntersectionEmpty => 6,
331 Self::Pending => 7,
332 Self::TooManyGroupChildCombinations => 8,
333 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
334 }
335 }
336
337 #[inline]
338 pub fn is_unknown(&self) -> bool {
339 match self {
340 Self::__SourceBreaking { unknown_ordinal: _ } => true,
341 _ => false,
342 }
343 }
344}
345
346#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
347pub struct PixelFormatAndModifier {
348 pub pixel_format: fidl_fuchsia_images2__common::PixelFormat,
356 pub pixel_format_modifier: fidl_fuchsia_images2__common::PixelFormatModifier,
361}
362
363impl fidl::Persistable for PixelFormatAndModifier {}
364
365#[derive(Clone, Debug, Default, PartialEq)]
366pub struct AllocatorSetDebugClientInfoRequest {
367 pub name: Option<String>,
368 pub id: Option<u64>,
369 #[doc(hidden)]
370 pub __source_breaking: fidl::marker::SourceBreaking,
371}
372
373impl fidl::Persistable for AllocatorSetDebugClientInfoRequest {}
374
375#[derive(Clone, Debug, Default, PartialEq)]
376pub struct AllocatorValidateBufferCollectionTokenRequest {
377 pub token_server_koid: Option<u64>,
378 #[doc(hidden)]
379 pub __source_breaking: fidl::marker::SourceBreaking,
380}
381
382impl fidl::Persistable for AllocatorValidateBufferCollectionTokenRequest {}
383
384#[derive(Clone, Debug, Default, PartialEq)]
385pub struct AllocatorValidateBufferCollectionTokenResponse {
386 pub is_known: Option<bool>,
387 #[doc(hidden)]
388 pub __source_breaking: fidl::marker::SourceBreaking,
389}
390
391impl fidl::Persistable for AllocatorValidateBufferCollectionTokenResponse {}
392
393#[derive(Clone, Debug, Default, PartialEq)]
398pub struct BufferCollectionConstraints {
399 pub usage: Option<BufferUsage>,
415 pub min_buffer_count_for_camping: Option<u32>,
441 pub min_buffer_count_for_dedicated_slack: Option<u32>,
458 pub min_buffer_count_for_shared_slack: Option<u32>,
474 pub min_buffer_count: Option<u32>,
483 pub max_buffer_count: Option<u32>,
491 pub buffer_memory_constraints: Option<BufferMemoryConstraints>,
501 pub image_format_constraints: Option<Vec<ImageFormatConstraints>>,
524 #[doc(hidden)]
525 pub __source_breaking: fidl::marker::SourceBreaking,
526}
527
528impl fidl::Persistable for BufferCollectionConstraints {}
529
530#[derive(Clone, Debug, Default, PartialEq)]
531pub struct BufferCollectionTokenDuplicateSyncRequest {
532 pub rights_attenuation_masks: Option<Vec<fidl::Rights>>,
533 #[doc(hidden)]
534 pub __source_breaking: fidl::marker::SourceBreaking,
535}
536
537impl fidl::Persistable for BufferCollectionTokenDuplicateSyncRequest {}
538
539#[derive(Clone, Debug, Default, PartialEq)]
540pub struct BufferCollectionTokenGroupCreateChildrenSyncRequest {
541 pub rights_attenuation_masks: Option<Vec<fidl::Rights>>,
542 #[doc(hidden)]
543 pub __source_breaking: fidl::marker::SourceBreaking,
544}
545
546impl fidl::Persistable for BufferCollectionTokenGroupCreateChildrenSyncRequest {}
547
548#[derive(Clone, Debug, Default, PartialEq)]
549pub struct BufferMemoryConstraints {
550 pub min_size_bytes: Option<u64>,
552 pub max_size_bytes: Option<u64>,
554 pub physically_contiguous_required: Option<bool>,
559 pub secure_required: Option<bool>,
563 pub cpu_domain_supported: Option<bool>,
582 pub ram_domain_supported: Option<bool>,
602 pub inaccessible_domain_supported: Option<bool>,
624 pub permitted_heaps: Option<Vec<Heap>>,
630 #[doc(hidden)]
631 pub __source_breaking: fidl::marker::SourceBreaking,
632}
633
634impl fidl::Persistable for BufferMemoryConstraints {}
635
636#[derive(Clone, Debug, Default, PartialEq)]
638pub struct BufferMemorySettings {
639 pub size_bytes: Option<u64>,
641 pub is_physically_contiguous: Option<bool>,
643 pub is_secure: Option<bool>,
645 pub coherency_domain: Option<CoherencyDomain>,
647 pub heap: Option<Heap>,
651 #[doc(hidden)]
652 pub __source_breaking: fidl::marker::SourceBreaking,
653}
654
655impl fidl::Persistable for BufferMemorySettings {}
656
657#[derive(Clone, Debug, Default, PartialEq)]
659pub struct BufferUsage {
660 pub none: Option<u32>,
667 pub cpu: Option<u32>,
669 pub vulkan: Option<u32>,
673 pub display: Option<u32>,
676 pub video: Option<u32>,
678 #[doc(hidden)]
679 pub __source_breaking: fidl::marker::SourceBreaking,
680}
681
682impl fidl::Persistable for BufferUsage {}
683
684#[derive(Clone, Debug, Default, PartialEq)]
713pub struct Config {
714 pub format_costs: Option<Vec<FormatCostEntry>>,
730 #[doc(hidden)]
731 pub __source_breaking: fidl::marker::SourceBreaking,
732}
733
734impl fidl::Persistable for Config {}
735
736#[derive(Clone, Debug, Default, PartialEq)]
737pub struct DynamicSecureHeap {
738 pub heap: Option<Heap>,
739 #[doc(hidden)]
740 pub __source_breaking: fidl::marker::SourceBreaking,
741}
742
743impl fidl::Persistable for DynamicSecureHeap {}
744
745#[derive(Clone, Debug, Default, PartialEq)]
781pub struct FormatCostEntry {
782 pub key: Option<FormatCostKey>,
785 pub cost: Option<f32>,
796 #[doc(hidden)]
797 pub __source_breaking: fidl::marker::SourceBreaking,
798}
799
800impl fidl::Persistable for FormatCostEntry {}
801
802#[derive(Clone, Debug, Default, PartialEq)]
807pub struct FormatCostKey {
808 pub pixel_format: Option<fidl_fuchsia_images2__common::PixelFormat>,
813 pub pixel_format_modifier: Option<fidl_fuchsia_images2__common::PixelFormatModifier>,
818 pub buffer_usage_bits: Option<BufferUsage>,
845 #[doc(hidden)]
846 pub __source_breaking: fidl::marker::SourceBreaking,
847}
848
849impl fidl::Persistable for FormatCostKey {}
850
851#[derive(Clone, Debug, Default, PartialEq)]
866pub struct FormatCosts {
867 pub format_costs: Option<Vec<FormatCostEntry>>,
872 #[doc(hidden)]
873 pub __source_breaking: fidl::marker::SourceBreaking,
874}
875
876impl fidl::Persistable for FormatCosts {}
877
878#[derive(Clone, Debug, Default, PartialEq)]
886pub struct Heap {
887 pub heap_type: Option<String>,
895 pub id: Option<u64>,
908 #[doc(hidden)]
909 pub __source_breaking: fidl::marker::SourceBreaking,
910}
911
912impl fidl::Persistable for Heap {}
913
914#[derive(Clone, Debug, Default, PartialEq)]
916pub struct ImageFormatConstraints {
917 pub pixel_format: Option<fidl_fuchsia_images2__common::PixelFormat>,
964 pub pixel_format_modifier: Option<fidl_fuchsia_images2__common::PixelFormatModifier>,
987 pub color_spaces: Option<Vec<fidl_fuchsia_images2__common::ColorSpace>>,
996 pub min_size: Option<fidl_fuchsia_math__common::SizeU>,
1022 pub max_size: Option<fidl_fuchsia_math__common::SizeU>,
1033 pub min_bytes_per_row: Option<u32>,
1067 pub max_bytes_per_row: Option<u32>,
1080 pub max_width_times_height: Option<u64>,
1108 pub size_alignment: Option<fidl_fuchsia_math__common::SizeU>,
1115 pub display_rect_alignment: Option<fidl_fuchsia_math__common::SizeU>,
1124 pub required_min_size: Option<fidl_fuchsia_math__common::SizeU>,
1154 pub required_max_size: Option<fidl_fuchsia_math__common::SizeU>,
1156 pub bytes_per_row_divisor: Option<u32>,
1183 pub start_offset_divisor: Option<u32>,
1190 pub pixel_format_and_modifiers: Option<Vec<PixelFormatAndModifier>>,
1258 pub require_bytes_per_row_at_pixel_boundary: Option<bool>,
1270 pub is_alpha_present: Option<bool>,
1299 #[doc(hidden)]
1300 pub __source_breaking: fidl::marker::SourceBreaking,
1301}
1302
1303impl fidl::Persistable for ImageFormatConstraints {}
1304
1305#[derive(Clone, Debug, Default, PartialEq)]
1306pub struct NodeSetDebugClientInfoRequest {
1307 pub name: Option<String>,
1308 pub id: Option<u64>,
1309 #[doc(hidden)]
1310 pub __source_breaking: fidl::marker::SourceBreaking,
1311}
1312
1313impl fidl::Persistable for NodeSetDebugClientInfoRequest {}
1314
1315#[derive(Clone, Debug, Default, PartialEq)]
1316pub struct NodeSetDebugTimeoutLogDeadlineRequest {
1317 pub deadline: Option<i64>,
1318 #[doc(hidden)]
1319 pub __source_breaking: fidl::marker::SourceBreaking,
1320}
1321
1322impl fidl::Persistable for NodeSetDebugTimeoutLogDeadlineRequest {}
1323
1324#[derive(Clone, Debug, Default, PartialEq)]
1325pub struct NodeSetNameRequest {
1326 pub priority: Option<u32>,
1327 pub name: Option<String>,
1328 #[doc(hidden)]
1329 pub __source_breaking: fidl::marker::SourceBreaking,
1330}
1331
1332impl fidl::Persistable for NodeSetNameRequest {}
1333
1334#[derive(Clone, Debug, Default, PartialEq)]
1335pub struct NodeGetBufferCollectionIdResponse {
1336 pub buffer_collection_id: Option<u64>,
1337 #[doc(hidden)]
1338 pub __source_breaking: fidl::marker::SourceBreaking,
1339}
1340
1341impl fidl::Persistable for NodeGetBufferCollectionIdResponse {}
1342
1343#[derive(Clone, Debug, Default, PartialEq)]
1344pub struct NodeIsAlternateForResponse {
1345 pub is_alternate: Option<bool>,
1346 #[doc(hidden)]
1347 pub __source_breaking: fidl::marker::SourceBreaking,
1348}
1349
1350impl fidl::Persistable for NodeIsAlternateForResponse {}
1351
1352#[derive(Clone, Debug, Default, PartialEq)]
1353pub struct SecureHeapAndRange {
1354 pub heap: Option<Heap>,
1355 pub range: Option<SecureHeapRange>,
1356 #[doc(hidden)]
1357 pub __source_breaking: fidl::marker::SourceBreaking,
1358}
1359
1360impl fidl::Persistable for SecureHeapAndRange {}
1361
1362#[derive(Clone, Debug, Default, PartialEq)]
1363pub struct SecureHeapAndRangeModification {
1364 pub heap: Option<Heap>,
1365 pub old_range: Option<SecureHeapRange>,
1366 pub new_range: Option<SecureHeapRange>,
1367 #[doc(hidden)]
1368 pub __source_breaking: fidl::marker::SourceBreaking,
1369}
1370
1371impl fidl::Persistable for SecureHeapAndRangeModification {}
1372
1373#[derive(Clone, Debug, Default, PartialEq)]
1374pub struct SecureHeapAndRanges {
1375 pub heap: Option<Heap>,
1377 pub ranges: Option<Vec<SecureHeapRange>>,
1382 #[doc(hidden)]
1383 pub __source_breaking: fidl::marker::SourceBreaking,
1384}
1385
1386impl fidl::Persistable for SecureHeapAndRanges {}
1387
1388#[derive(Clone, Debug, Default, PartialEq)]
1389pub struct SecureHeapProperties {
1390 pub heap: Option<Heap>,
1392 pub dynamic_protection_ranges: Option<bool>,
1400 pub protected_range_granularity: Option<u32>,
1410 pub max_protected_range_count: Option<u64>,
1423 pub is_mod_protected_range_available: Option<bool>,
1429 #[doc(hidden)]
1430 pub __source_breaking: fidl::marker::SourceBreaking,
1431}
1432
1433impl fidl::Persistable for SecureHeapProperties {}
1434
1435#[derive(Clone, Debug, Default, PartialEq)]
1436pub struct SecureHeapRange {
1437 pub physical_address: Option<u64>,
1439 pub size_bytes: Option<u64>,
1441 #[doc(hidden)]
1442 pub __source_breaking: fidl::marker::SourceBreaking,
1443}
1444
1445impl fidl::Persistable for SecureHeapRange {}
1446
1447#[derive(Clone, Debug, Default, PartialEq)]
1448pub struct SecureMemAddSecureHeapPhysicalRangeRequest {
1449 pub heap_range: Option<SecureHeapAndRange>,
1450 #[doc(hidden)]
1451 pub __source_breaking: fidl::marker::SourceBreaking,
1452}
1453
1454impl fidl::Persistable for SecureMemAddSecureHeapPhysicalRangeRequest {}
1455
1456#[derive(Clone, Debug, Default, PartialEq)]
1457pub struct SecureMemDeleteSecureHeapPhysicalRangeRequest {
1458 pub heap_range: Option<SecureHeapAndRange>,
1459 #[doc(hidden)]
1460 pub __source_breaking: fidl::marker::SourceBreaking,
1461}
1462
1463impl fidl::Persistable for SecureMemDeleteSecureHeapPhysicalRangeRequest {}
1464
1465#[derive(Clone, Debug, Default, PartialEq)]
1466pub struct SecureMemGetPhysicalSecureHeapPropertiesRequest {
1467 pub entire_heap: Option<SecureHeapAndRange>,
1468 #[doc(hidden)]
1469 pub __source_breaking: fidl::marker::SourceBreaking,
1470}
1471
1472impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesRequest {}
1473
1474#[derive(Clone, Debug, Default, PartialEq)]
1475pub struct SecureMemModifySecureHeapPhysicalRangeRequest {
1476 pub range_modification: Option<SecureHeapAndRangeModification>,
1477 #[doc(hidden)]
1478 pub __source_breaking: fidl::marker::SourceBreaking,
1479}
1480
1481impl fidl::Persistable for SecureMemModifySecureHeapPhysicalRangeRequest {}
1482
1483#[derive(Clone, Debug, Default, PartialEq)]
1484pub struct SecureMemZeroSubRangeRequest {
1485 pub is_covering_range_explicit: Option<bool>,
1486 pub heap_range: Option<SecureHeapAndRange>,
1487 #[doc(hidden)]
1488 pub __source_breaking: fidl::marker::SourceBreaking,
1489}
1490
1491impl fidl::Persistable for SecureMemZeroSubRangeRequest {}
1492
1493#[derive(Clone, Debug, Default, PartialEq)]
1494pub struct SecureMemGetDynamicSecureHeapsResponse {
1495 pub heaps: Option<Vec<DynamicSecureHeap>>,
1496 #[doc(hidden)]
1497 pub __source_breaking: fidl::marker::SourceBreaking,
1498}
1499
1500impl fidl::Persistable for SecureMemGetDynamicSecureHeapsResponse {}
1501
1502#[derive(Clone, Debug, Default, PartialEq)]
1503pub struct SecureMemGetPhysicalSecureHeapPropertiesResponse {
1504 pub properties: Option<SecureHeapProperties>,
1505 #[doc(hidden)]
1506 pub __source_breaking: fidl::marker::SourceBreaking,
1507}
1508
1509impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesResponse {}
1510
1511#[derive(Clone, Debug, Default, PartialEq)]
1512pub struct SecureMemGetPhysicalSecureHeapsResponse {
1513 pub heaps: Option<Vec<SecureHeapAndRanges>>,
1514 #[doc(hidden)]
1515 pub __source_breaking: fidl::marker::SourceBreaking,
1516}
1517
1518impl fidl::Persistable for SecureMemGetPhysicalSecureHeapsResponse {}
1519
1520#[derive(Clone, Debug, Default, PartialEq)]
1522pub struct SingleBufferSettings {
1523 pub buffer_settings: Option<BufferMemorySettings>,
1525 pub image_format_constraints: Option<ImageFormatConstraints>,
1534 #[doc(hidden)]
1535 pub __source_breaking: fidl::marker::SourceBreaking,
1536}
1537
1538impl fidl::Persistable for SingleBufferSettings {}
1539
1540pub mod allocator_ordinals {
1541 pub const ALLOCATE_NON_SHARED_COLLECTION: u64 = 0x5ca681f025a80e44;
1542 pub const ALLOCATE_SHARED_COLLECTION: u64 = 0x11a19ff51f0b49c1;
1543 pub const BIND_SHARED_COLLECTION: u64 = 0x550916b0dc1d5b4e;
1544 pub const VALIDATE_BUFFER_COLLECTION_TOKEN: u64 = 0x4c5ee91b02a7e68d;
1545 pub const SET_DEBUG_CLIENT_INFO: u64 = 0x6f68f19a3f509c4d;
1546 pub const GET_VMO_INFO: u64 = 0x21a881120aa0ddf9;
1547}
1548
1549pub mod buffer_collection_ordinals {
1550 pub const SYNC: u64 = 0x11ac2555cf575b54;
1551 pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1552 pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1553 pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1554 pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1555 pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1556 pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1557 pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1558 pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1559 pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1560 pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1561 pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1562 pub const SET_CONSTRAINTS: u64 = 0x1fde0f19d650197b;
1563 pub const WAIT_FOR_ALL_BUFFERS_ALLOCATED: u64 = 0x62300344b61404e;
1564 pub const CHECK_ALL_BUFFERS_ALLOCATED: u64 = 0x35a5fe77ce939c10;
1565 pub const ATTACH_TOKEN: u64 = 0x46ac7d0008492982;
1566 pub const ATTACH_LIFETIME_TRACKING: u64 = 0x3ecb510113116dcf;
1567}
1568
1569pub mod buffer_collection_token_ordinals {
1570 pub const SYNC: u64 = 0x11ac2555cf575b54;
1571 pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1572 pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1573 pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1574 pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1575 pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1576 pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1577 pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1578 pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1579 pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1580 pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1581 pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1582 pub const DUPLICATE_SYNC: u64 = 0x1c1af9919d1ca45c;
1583 pub const DUPLICATE: u64 = 0x73e78f92ee7fb887;
1584 pub const SET_DISPENSABLE: u64 = 0x228acf979254df8b;
1585 pub const CREATE_BUFFER_COLLECTION_TOKEN_GROUP: u64 = 0x30f8d48e77bd36f2;
1586}
1587
1588pub mod buffer_collection_token_group_ordinals {
1589 pub const SYNC: u64 = 0x11ac2555cf575b54;
1590 pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1591 pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1592 pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1593 pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1594 pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1595 pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1596 pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1597 pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1598 pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1599 pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1600 pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1601 pub const CREATE_CHILD: u64 = 0x41a0075d419f30c5;
1602 pub const CREATE_CHILDREN_SYNC: u64 = 0x15dea448c536070a;
1603 pub const ALL_CHILDREN_PRESENT: u64 = 0x5c327e4a23391312;
1604}
1605
1606pub mod node_ordinals {
1607 pub const SYNC: u64 = 0x11ac2555cf575b54;
1608 pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1609 pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1610 pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1611 pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1612 pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1613 pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1614 pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1615 pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1616 pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1617 pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1618 pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1619}
1620
1621pub mod secure_mem_ordinals {
1622 pub const GET_PHYSICAL_SECURE_HEAPS: u64 = 0x38716300592073e3;
1623 pub const GET_DYNAMIC_SECURE_HEAPS: u64 = 0x1190847f99952834;
1624 pub const GET_PHYSICAL_SECURE_HEAP_PROPERTIES: u64 = 0xc6f06889009c7bc;
1625 pub const ADD_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x35f695b9b6c7217a;
1626 pub const DELETE_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0xeaa58c650264c9e;
1627 pub const MODIFY_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x60b7448aa1187734;
1628 pub const ZERO_SUB_RANGE: u64 = 0x5b25b7901a385ce5;
1629}
1630
1631mod internal {
1632 use super::*;
1633 unsafe impl fidl::encoding::TypeMarker for CoherencyDomain {
1634 type Owned = Self;
1635
1636 #[inline(always)]
1637 fn inline_align(_context: fidl::encoding::Context) -> usize {
1638 std::mem::align_of::<u32>()
1639 }
1640
1641 #[inline(always)]
1642 fn inline_size(_context: fidl::encoding::Context) -> usize {
1643 std::mem::size_of::<u32>()
1644 }
1645
1646 #[inline(always)]
1647 fn encode_is_copy() -> bool {
1648 false
1649 }
1650
1651 #[inline(always)]
1652 fn decode_is_copy() -> bool {
1653 false
1654 }
1655 }
1656
1657 impl fidl::encoding::ValueTypeMarker for CoherencyDomain {
1658 type Borrowed<'a> = Self;
1659 #[inline(always)]
1660 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1661 *value
1662 }
1663 }
1664
1665 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1666 for CoherencyDomain
1667 {
1668 #[inline]
1669 unsafe fn encode(
1670 self,
1671 encoder: &mut fidl::encoding::Encoder<'_, D>,
1672 offset: usize,
1673 _depth: fidl::encoding::Depth,
1674 ) -> fidl::Result<()> {
1675 encoder.debug_check_bounds::<Self>(offset);
1676 encoder.write_num(self.into_primitive(), offset);
1677 Ok(())
1678 }
1679 }
1680
1681 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoherencyDomain {
1682 #[inline(always)]
1683 fn new_empty() -> Self {
1684 Self::unknown()
1685 }
1686
1687 #[inline]
1688 unsafe fn decode(
1689 &mut self,
1690 decoder: &mut fidl::encoding::Decoder<'_, D>,
1691 offset: usize,
1692 _depth: fidl::encoding::Depth,
1693 ) -> fidl::Result<()> {
1694 decoder.debug_check_bounds::<Self>(offset);
1695 let prim = decoder.read_num::<u32>(offset);
1696
1697 *self = Self::from_primitive_allow_unknown(prim);
1698 Ok(())
1699 }
1700 }
1701 unsafe impl fidl::encoding::TypeMarker for Error {
1702 type Owned = Self;
1703
1704 #[inline(always)]
1705 fn inline_align(_context: fidl::encoding::Context) -> usize {
1706 std::mem::align_of::<u32>()
1707 }
1708
1709 #[inline(always)]
1710 fn inline_size(_context: fidl::encoding::Context) -> usize {
1711 std::mem::size_of::<u32>()
1712 }
1713
1714 #[inline(always)]
1715 fn encode_is_copy() -> bool {
1716 false
1717 }
1718
1719 #[inline(always)]
1720 fn decode_is_copy() -> bool {
1721 false
1722 }
1723 }
1724
1725 impl fidl::encoding::ValueTypeMarker for Error {
1726 type Borrowed<'a> = Self;
1727 #[inline(always)]
1728 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1729 *value
1730 }
1731 }
1732
1733 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
1734 #[inline]
1735 unsafe fn encode(
1736 self,
1737 encoder: &mut fidl::encoding::Encoder<'_, D>,
1738 offset: usize,
1739 _depth: fidl::encoding::Depth,
1740 ) -> fidl::Result<()> {
1741 encoder.debug_check_bounds::<Self>(offset);
1742 encoder.write_num(self.into_primitive(), offset);
1743 Ok(())
1744 }
1745 }
1746
1747 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
1748 #[inline(always)]
1749 fn new_empty() -> Self {
1750 Self::unknown()
1751 }
1752
1753 #[inline]
1754 unsafe fn decode(
1755 &mut self,
1756 decoder: &mut fidl::encoding::Decoder<'_, D>,
1757 offset: usize,
1758 _depth: fidl::encoding::Depth,
1759 ) -> fidl::Result<()> {
1760 decoder.debug_check_bounds::<Self>(offset);
1761 let prim = decoder.read_num::<u32>(offset);
1762
1763 *self = Self::from_primitive_allow_unknown(prim);
1764 Ok(())
1765 }
1766 }
1767
1768 impl fidl::encoding::ValueTypeMarker for PixelFormatAndModifier {
1769 type Borrowed<'a> = &'a Self;
1770 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1771 value
1772 }
1773 }
1774
1775 unsafe impl fidl::encoding::TypeMarker for PixelFormatAndModifier {
1776 type Owned = Self;
1777
1778 #[inline(always)]
1779 fn inline_align(_context: fidl::encoding::Context) -> usize {
1780 8
1781 }
1782
1783 #[inline(always)]
1784 fn inline_size(_context: fidl::encoding::Context) -> usize {
1785 16
1786 }
1787 }
1788
1789 unsafe impl<D: fidl::encoding::ResourceDialect>
1790 fidl::encoding::Encode<PixelFormatAndModifier, D> for &PixelFormatAndModifier
1791 {
1792 #[inline]
1793 unsafe fn encode(
1794 self,
1795 encoder: &mut fidl::encoding::Encoder<'_, D>,
1796 offset: usize,
1797 _depth: fidl::encoding::Depth,
1798 ) -> fidl::Result<()> {
1799 encoder.debug_check_bounds::<PixelFormatAndModifier>(offset);
1800 fidl::encoding::Encode::<PixelFormatAndModifier, D>::encode(
1802 (
1803 <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
1804 <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format_modifier),
1805 ),
1806 encoder, offset, _depth
1807 )
1808 }
1809 }
1810 unsafe impl<
1811 D: fidl::encoding::ResourceDialect,
1812 T0: fidl::encoding::Encode<fidl_fuchsia_images2__common::PixelFormat, D>,
1813 T1: fidl::encoding::Encode<fidl_fuchsia_images2__common::PixelFormatModifier, D>,
1814 > fidl::encoding::Encode<PixelFormatAndModifier, D> for (T0, T1)
1815 {
1816 #[inline]
1817 unsafe fn encode(
1818 self,
1819 encoder: &mut fidl::encoding::Encoder<'_, D>,
1820 offset: usize,
1821 depth: fidl::encoding::Depth,
1822 ) -> fidl::Result<()> {
1823 encoder.debug_check_bounds::<PixelFormatAndModifier>(offset);
1824 unsafe {
1827 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1828 (ptr as *mut u64).write_unaligned(0);
1829 }
1830 self.0.encode(encoder, offset + 0, depth)?;
1832 self.1.encode(encoder, offset + 8, depth)?;
1833 Ok(())
1834 }
1835 }
1836
1837 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1838 for PixelFormatAndModifier
1839 {
1840 #[inline(always)]
1841 fn new_empty() -> Self {
1842 Self {
1843 pixel_format: fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D),
1844 pixel_format_modifier: fidl::new_empty!(
1845 fidl_fuchsia_images2__common::PixelFormatModifier,
1846 D
1847 ),
1848 }
1849 }
1850
1851 #[inline]
1852 unsafe fn decode(
1853 &mut self,
1854 decoder: &mut fidl::encoding::Decoder<'_, D>,
1855 offset: usize,
1856 _depth: fidl::encoding::Depth,
1857 ) -> fidl::Result<()> {
1858 decoder.debug_check_bounds::<Self>(offset);
1859 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1861 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1862 let mask = 0xffffffff00000000u64;
1863 let maskedval = padval & mask;
1864 if maskedval != 0 {
1865 return Err(fidl::Error::NonZeroPadding {
1866 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1867 });
1868 }
1869 fidl::decode!(
1870 fidl_fuchsia_images2__common::PixelFormat,
1871 D,
1872 &mut self.pixel_format,
1873 decoder,
1874 offset + 0,
1875 _depth
1876 )?;
1877 fidl::decode!(
1878 fidl_fuchsia_images2__common::PixelFormatModifier,
1879 D,
1880 &mut self.pixel_format_modifier,
1881 decoder,
1882 offset + 8,
1883 _depth
1884 )?;
1885 Ok(())
1886 }
1887 }
1888
1889 impl AllocatorSetDebugClientInfoRequest {
1890 #[inline(always)]
1891 fn max_ordinal_present(&self) -> u64 {
1892 if let Some(_) = self.id {
1893 return 2;
1894 }
1895 if let Some(_) = self.name {
1896 return 1;
1897 }
1898 0
1899 }
1900 }
1901
1902 impl fidl::encoding::ValueTypeMarker for AllocatorSetDebugClientInfoRequest {
1903 type Borrowed<'a> = &'a Self;
1904 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1905 value
1906 }
1907 }
1908
1909 unsafe impl fidl::encoding::TypeMarker for AllocatorSetDebugClientInfoRequest {
1910 type Owned = Self;
1911
1912 #[inline(always)]
1913 fn inline_align(_context: fidl::encoding::Context) -> usize {
1914 8
1915 }
1916
1917 #[inline(always)]
1918 fn inline_size(_context: fidl::encoding::Context) -> usize {
1919 16
1920 }
1921 }
1922
1923 unsafe impl<D: fidl::encoding::ResourceDialect>
1924 fidl::encoding::Encode<AllocatorSetDebugClientInfoRequest, D>
1925 for &AllocatorSetDebugClientInfoRequest
1926 {
1927 unsafe fn encode(
1928 self,
1929 encoder: &mut fidl::encoding::Encoder<'_, D>,
1930 offset: usize,
1931 mut depth: fidl::encoding::Depth,
1932 ) -> fidl::Result<()> {
1933 encoder.debug_check_bounds::<AllocatorSetDebugClientInfoRequest>(offset);
1934 let max_ordinal: u64 = self.max_ordinal_present();
1936 encoder.write_num(max_ordinal, offset);
1937 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1938 if max_ordinal == 0 {
1940 return Ok(());
1941 }
1942 depth.increment()?;
1943 let envelope_size = 8;
1944 let bytes_len = max_ordinal as usize * envelope_size;
1945 #[allow(unused_variables)]
1946 let offset = encoder.out_of_line_offset(bytes_len);
1947 let mut _prev_end_offset: usize = 0;
1948 if 1 > max_ordinal {
1949 return Ok(());
1950 }
1951
1952 let cur_offset: usize = (1 - 1) * envelope_size;
1955
1956 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1958
1959 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
1964 self.name.as_ref().map(
1965 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
1966 ),
1967 encoder,
1968 offset + cur_offset,
1969 depth,
1970 )?;
1971
1972 _prev_end_offset = cur_offset + envelope_size;
1973 if 2 > max_ordinal {
1974 return Ok(());
1975 }
1976
1977 let cur_offset: usize = (2 - 1) * envelope_size;
1980
1981 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1983
1984 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1989 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1990 encoder,
1991 offset + cur_offset,
1992 depth,
1993 )?;
1994
1995 _prev_end_offset = cur_offset + envelope_size;
1996
1997 Ok(())
1998 }
1999 }
2000
2001 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2002 for AllocatorSetDebugClientInfoRequest
2003 {
2004 #[inline(always)]
2005 fn new_empty() -> Self {
2006 Self::default()
2007 }
2008
2009 unsafe fn decode(
2010 &mut self,
2011 decoder: &mut fidl::encoding::Decoder<'_, D>,
2012 offset: usize,
2013 mut depth: fidl::encoding::Depth,
2014 ) -> fidl::Result<()> {
2015 decoder.debug_check_bounds::<Self>(offset);
2016 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2017 None => return Err(fidl::Error::NotNullable),
2018 Some(len) => len,
2019 };
2020 if len == 0 {
2022 return Ok(());
2023 };
2024 depth.increment()?;
2025 let envelope_size = 8;
2026 let bytes_len = len * envelope_size;
2027 let offset = decoder.out_of_line_offset(bytes_len)?;
2028 let mut _next_ordinal_to_read = 0;
2030 let mut next_offset = offset;
2031 let end_offset = offset + bytes_len;
2032 _next_ordinal_to_read += 1;
2033 if next_offset >= end_offset {
2034 return Ok(());
2035 }
2036
2037 while _next_ordinal_to_read < 1 {
2039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2040 _next_ordinal_to_read += 1;
2041 next_offset += envelope_size;
2042 }
2043
2044 let next_out_of_line = decoder.next_out_of_line();
2045 let handles_before = decoder.remaining_handles();
2046 if let Some((inlined, num_bytes, num_handles)) =
2047 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2048 {
2049 let member_inline_size =
2050 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
2051 decoder.context,
2052 );
2053 if inlined != (member_inline_size <= 4) {
2054 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2055 }
2056 let inner_offset;
2057 let mut inner_depth = depth.clone();
2058 if inlined {
2059 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2060 inner_offset = next_offset;
2061 } else {
2062 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2063 inner_depth.increment()?;
2064 }
2065 let val_ref = self
2066 .name
2067 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
2068 fidl::decode!(
2069 fidl::encoding::BoundedString<256>,
2070 D,
2071 val_ref,
2072 decoder,
2073 inner_offset,
2074 inner_depth
2075 )?;
2076 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2077 {
2078 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2079 }
2080 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2081 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2082 }
2083 }
2084
2085 next_offset += envelope_size;
2086 _next_ordinal_to_read += 1;
2087 if next_offset >= end_offset {
2088 return Ok(());
2089 }
2090
2091 while _next_ordinal_to_read < 2 {
2093 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2094 _next_ordinal_to_read += 1;
2095 next_offset += envelope_size;
2096 }
2097
2098 let next_out_of_line = decoder.next_out_of_line();
2099 let handles_before = decoder.remaining_handles();
2100 if let Some((inlined, num_bytes, num_handles)) =
2101 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2102 {
2103 let member_inline_size =
2104 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2105 if inlined != (member_inline_size <= 4) {
2106 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2107 }
2108 let inner_offset;
2109 let mut inner_depth = depth.clone();
2110 if inlined {
2111 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2112 inner_offset = next_offset;
2113 } else {
2114 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2115 inner_depth.increment()?;
2116 }
2117 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2118 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2119 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2120 {
2121 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2122 }
2123 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2124 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2125 }
2126 }
2127
2128 next_offset += envelope_size;
2129
2130 while next_offset < end_offset {
2132 _next_ordinal_to_read += 1;
2133 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2134 next_offset += envelope_size;
2135 }
2136
2137 Ok(())
2138 }
2139 }
2140
2141 impl AllocatorValidateBufferCollectionTokenRequest {
2142 #[inline(always)]
2143 fn max_ordinal_present(&self) -> u64 {
2144 if let Some(_) = self.token_server_koid {
2145 return 1;
2146 }
2147 0
2148 }
2149 }
2150
2151 impl fidl::encoding::ValueTypeMarker for AllocatorValidateBufferCollectionTokenRequest {
2152 type Borrowed<'a> = &'a Self;
2153 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2154 value
2155 }
2156 }
2157
2158 unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenRequest {
2159 type Owned = Self;
2160
2161 #[inline(always)]
2162 fn inline_align(_context: fidl::encoding::Context) -> usize {
2163 8
2164 }
2165
2166 #[inline(always)]
2167 fn inline_size(_context: fidl::encoding::Context) -> usize {
2168 16
2169 }
2170 }
2171
2172 unsafe impl<D: fidl::encoding::ResourceDialect>
2173 fidl::encoding::Encode<AllocatorValidateBufferCollectionTokenRequest, D>
2174 for &AllocatorValidateBufferCollectionTokenRequest
2175 {
2176 unsafe fn encode(
2177 self,
2178 encoder: &mut fidl::encoding::Encoder<'_, D>,
2179 offset: usize,
2180 mut depth: fidl::encoding::Depth,
2181 ) -> fidl::Result<()> {
2182 encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenRequest>(offset);
2183 let max_ordinal: u64 = self.max_ordinal_present();
2185 encoder.write_num(max_ordinal, offset);
2186 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2187 if max_ordinal == 0 {
2189 return Ok(());
2190 }
2191 depth.increment()?;
2192 let envelope_size = 8;
2193 let bytes_len = max_ordinal as usize * envelope_size;
2194 #[allow(unused_variables)]
2195 let offset = encoder.out_of_line_offset(bytes_len);
2196 let mut _prev_end_offset: usize = 0;
2197 if 1 > max_ordinal {
2198 return Ok(());
2199 }
2200
2201 let cur_offset: usize = (1 - 1) * envelope_size;
2204
2205 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2207
2208 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2213 self.token_server_koid
2214 .as_ref()
2215 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2216 encoder,
2217 offset + cur_offset,
2218 depth,
2219 )?;
2220
2221 _prev_end_offset = cur_offset + envelope_size;
2222
2223 Ok(())
2224 }
2225 }
2226
2227 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2228 for AllocatorValidateBufferCollectionTokenRequest
2229 {
2230 #[inline(always)]
2231 fn new_empty() -> Self {
2232 Self::default()
2233 }
2234
2235 unsafe fn decode(
2236 &mut self,
2237 decoder: &mut fidl::encoding::Decoder<'_, D>,
2238 offset: usize,
2239 mut depth: fidl::encoding::Depth,
2240 ) -> fidl::Result<()> {
2241 decoder.debug_check_bounds::<Self>(offset);
2242 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2243 None => return Err(fidl::Error::NotNullable),
2244 Some(len) => len,
2245 };
2246 if len == 0 {
2248 return Ok(());
2249 };
2250 depth.increment()?;
2251 let envelope_size = 8;
2252 let bytes_len = len * envelope_size;
2253 let offset = decoder.out_of_line_offset(bytes_len)?;
2254 let mut _next_ordinal_to_read = 0;
2256 let mut next_offset = offset;
2257 let end_offset = offset + bytes_len;
2258 _next_ordinal_to_read += 1;
2259 if next_offset >= end_offset {
2260 return Ok(());
2261 }
2262
2263 while _next_ordinal_to_read < 1 {
2265 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2266 _next_ordinal_to_read += 1;
2267 next_offset += envelope_size;
2268 }
2269
2270 let next_out_of_line = decoder.next_out_of_line();
2271 let handles_before = decoder.remaining_handles();
2272 if let Some((inlined, num_bytes, num_handles)) =
2273 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2274 {
2275 let member_inline_size =
2276 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2277 if inlined != (member_inline_size <= 4) {
2278 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2279 }
2280 let inner_offset;
2281 let mut inner_depth = depth.clone();
2282 if inlined {
2283 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2284 inner_offset = next_offset;
2285 } else {
2286 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2287 inner_depth.increment()?;
2288 }
2289 let val_ref =
2290 self.token_server_koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
2291 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2292 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2293 {
2294 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2295 }
2296 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2297 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2298 }
2299 }
2300
2301 next_offset += envelope_size;
2302
2303 while next_offset < end_offset {
2305 _next_ordinal_to_read += 1;
2306 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2307 next_offset += envelope_size;
2308 }
2309
2310 Ok(())
2311 }
2312 }
2313
2314 impl AllocatorValidateBufferCollectionTokenResponse {
2315 #[inline(always)]
2316 fn max_ordinal_present(&self) -> u64 {
2317 if let Some(_) = self.is_known {
2318 return 1;
2319 }
2320 0
2321 }
2322 }
2323
2324 impl fidl::encoding::ValueTypeMarker for AllocatorValidateBufferCollectionTokenResponse {
2325 type Borrowed<'a> = &'a Self;
2326 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2327 value
2328 }
2329 }
2330
2331 unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenResponse {
2332 type Owned = Self;
2333
2334 #[inline(always)]
2335 fn inline_align(_context: fidl::encoding::Context) -> usize {
2336 8
2337 }
2338
2339 #[inline(always)]
2340 fn inline_size(_context: fidl::encoding::Context) -> usize {
2341 16
2342 }
2343 }
2344
2345 unsafe impl<D: fidl::encoding::ResourceDialect>
2346 fidl::encoding::Encode<AllocatorValidateBufferCollectionTokenResponse, D>
2347 for &AllocatorValidateBufferCollectionTokenResponse
2348 {
2349 unsafe fn encode(
2350 self,
2351 encoder: &mut fidl::encoding::Encoder<'_, D>,
2352 offset: usize,
2353 mut depth: fidl::encoding::Depth,
2354 ) -> fidl::Result<()> {
2355 encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenResponse>(offset);
2356 let max_ordinal: u64 = self.max_ordinal_present();
2358 encoder.write_num(max_ordinal, offset);
2359 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2360 if max_ordinal == 0 {
2362 return Ok(());
2363 }
2364 depth.increment()?;
2365 let envelope_size = 8;
2366 let bytes_len = max_ordinal as usize * envelope_size;
2367 #[allow(unused_variables)]
2368 let offset = encoder.out_of_line_offset(bytes_len);
2369 let mut _prev_end_offset: usize = 0;
2370 if 1 > max_ordinal {
2371 return Ok(());
2372 }
2373
2374 let cur_offset: usize = (1 - 1) * envelope_size;
2377
2378 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2380
2381 fidl::encoding::encode_in_envelope_optional::<bool, D>(
2386 self.is_known.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2387 encoder,
2388 offset + cur_offset,
2389 depth,
2390 )?;
2391
2392 _prev_end_offset = cur_offset + envelope_size;
2393
2394 Ok(())
2395 }
2396 }
2397
2398 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2399 for AllocatorValidateBufferCollectionTokenResponse
2400 {
2401 #[inline(always)]
2402 fn new_empty() -> Self {
2403 Self::default()
2404 }
2405
2406 unsafe fn decode(
2407 &mut self,
2408 decoder: &mut fidl::encoding::Decoder<'_, D>,
2409 offset: usize,
2410 mut depth: fidl::encoding::Depth,
2411 ) -> fidl::Result<()> {
2412 decoder.debug_check_bounds::<Self>(offset);
2413 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2414 None => return Err(fidl::Error::NotNullable),
2415 Some(len) => len,
2416 };
2417 if len == 0 {
2419 return Ok(());
2420 };
2421 depth.increment()?;
2422 let envelope_size = 8;
2423 let bytes_len = len * envelope_size;
2424 let offset = decoder.out_of_line_offset(bytes_len)?;
2425 let mut _next_ordinal_to_read = 0;
2427 let mut next_offset = offset;
2428 let end_offset = offset + bytes_len;
2429 _next_ordinal_to_read += 1;
2430 if next_offset >= end_offset {
2431 return Ok(());
2432 }
2433
2434 while _next_ordinal_to_read < 1 {
2436 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2437 _next_ordinal_to_read += 1;
2438 next_offset += envelope_size;
2439 }
2440
2441 let next_out_of_line = decoder.next_out_of_line();
2442 let handles_before = decoder.remaining_handles();
2443 if let Some((inlined, num_bytes, num_handles)) =
2444 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2445 {
2446 let member_inline_size =
2447 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2448 if inlined != (member_inline_size <= 4) {
2449 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2450 }
2451 let inner_offset;
2452 let mut inner_depth = depth.clone();
2453 if inlined {
2454 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2455 inner_offset = next_offset;
2456 } else {
2457 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2458 inner_depth.increment()?;
2459 }
2460 let val_ref = self.is_known.get_or_insert_with(|| fidl::new_empty!(bool, D));
2461 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2462 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2463 {
2464 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2465 }
2466 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2467 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2468 }
2469 }
2470
2471 next_offset += envelope_size;
2472
2473 while next_offset < end_offset {
2475 _next_ordinal_to_read += 1;
2476 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2477 next_offset += envelope_size;
2478 }
2479
2480 Ok(())
2481 }
2482 }
2483
2484 impl BufferCollectionConstraints {
2485 #[inline(always)]
2486 fn max_ordinal_present(&self) -> u64 {
2487 if let Some(_) = self.image_format_constraints {
2488 return 8;
2489 }
2490 if let Some(_) = self.buffer_memory_constraints {
2491 return 7;
2492 }
2493 if let Some(_) = self.max_buffer_count {
2494 return 6;
2495 }
2496 if let Some(_) = self.min_buffer_count {
2497 return 5;
2498 }
2499 if let Some(_) = self.min_buffer_count_for_shared_slack {
2500 return 4;
2501 }
2502 if let Some(_) = self.min_buffer_count_for_dedicated_slack {
2503 return 3;
2504 }
2505 if let Some(_) = self.min_buffer_count_for_camping {
2506 return 2;
2507 }
2508 if let Some(_) = self.usage {
2509 return 1;
2510 }
2511 0
2512 }
2513 }
2514
2515 impl fidl::encoding::ValueTypeMarker for BufferCollectionConstraints {
2516 type Borrowed<'a> = &'a Self;
2517 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2518 value
2519 }
2520 }
2521
2522 unsafe impl fidl::encoding::TypeMarker for BufferCollectionConstraints {
2523 type Owned = Self;
2524
2525 #[inline(always)]
2526 fn inline_align(_context: fidl::encoding::Context) -> usize {
2527 8
2528 }
2529
2530 #[inline(always)]
2531 fn inline_size(_context: fidl::encoding::Context) -> usize {
2532 16
2533 }
2534 }
2535
2536 unsafe impl<D: fidl::encoding::ResourceDialect>
2537 fidl::encoding::Encode<BufferCollectionConstraints, D> for &BufferCollectionConstraints
2538 {
2539 unsafe fn encode(
2540 self,
2541 encoder: &mut fidl::encoding::Encoder<'_, D>,
2542 offset: usize,
2543 mut depth: fidl::encoding::Depth,
2544 ) -> fidl::Result<()> {
2545 encoder.debug_check_bounds::<BufferCollectionConstraints>(offset);
2546 let max_ordinal: u64 = self.max_ordinal_present();
2548 encoder.write_num(max_ordinal, offset);
2549 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2550 if max_ordinal == 0 {
2552 return Ok(());
2553 }
2554 depth.increment()?;
2555 let envelope_size = 8;
2556 let bytes_len = max_ordinal as usize * envelope_size;
2557 #[allow(unused_variables)]
2558 let offset = encoder.out_of_line_offset(bytes_len);
2559 let mut _prev_end_offset: usize = 0;
2560 if 1 > max_ordinal {
2561 return Ok(());
2562 }
2563
2564 let cur_offset: usize = (1 - 1) * envelope_size;
2567
2568 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2570
2571 fidl::encoding::encode_in_envelope_optional::<BufferUsage, D>(
2576 self.usage.as_ref().map(<BufferUsage as fidl::encoding::ValueTypeMarker>::borrow),
2577 encoder,
2578 offset + cur_offset,
2579 depth,
2580 )?;
2581
2582 _prev_end_offset = cur_offset + envelope_size;
2583 if 2 > max_ordinal {
2584 return Ok(());
2585 }
2586
2587 let cur_offset: usize = (2 - 1) * envelope_size;
2590
2591 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2593
2594 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2599 self.min_buffer_count_for_camping
2600 .as_ref()
2601 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2602 encoder,
2603 offset + cur_offset,
2604 depth,
2605 )?;
2606
2607 _prev_end_offset = cur_offset + envelope_size;
2608 if 3 > max_ordinal {
2609 return Ok(());
2610 }
2611
2612 let cur_offset: usize = (3 - 1) * envelope_size;
2615
2616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2618
2619 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2624 self.min_buffer_count_for_dedicated_slack
2625 .as_ref()
2626 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2627 encoder,
2628 offset + cur_offset,
2629 depth,
2630 )?;
2631
2632 _prev_end_offset = cur_offset + envelope_size;
2633 if 4 > max_ordinal {
2634 return Ok(());
2635 }
2636
2637 let cur_offset: usize = (4 - 1) * envelope_size;
2640
2641 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2643
2644 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2649 self.min_buffer_count_for_shared_slack
2650 .as_ref()
2651 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2652 encoder,
2653 offset + cur_offset,
2654 depth,
2655 )?;
2656
2657 _prev_end_offset = cur_offset + envelope_size;
2658 if 5 > max_ordinal {
2659 return Ok(());
2660 }
2661
2662 let cur_offset: usize = (5 - 1) * envelope_size;
2665
2666 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2668
2669 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2674 self.min_buffer_count
2675 .as_ref()
2676 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2677 encoder,
2678 offset + cur_offset,
2679 depth,
2680 )?;
2681
2682 _prev_end_offset = cur_offset + envelope_size;
2683 if 6 > max_ordinal {
2684 return Ok(());
2685 }
2686
2687 let cur_offset: usize = (6 - 1) * envelope_size;
2690
2691 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2693
2694 fidl::encoding::encode_in_envelope_optional::<u32, D>(
2699 self.max_buffer_count
2700 .as_ref()
2701 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2702 encoder,
2703 offset + cur_offset,
2704 depth,
2705 )?;
2706
2707 _prev_end_offset = cur_offset + envelope_size;
2708 if 7 > max_ordinal {
2709 return Ok(());
2710 }
2711
2712 let cur_offset: usize = (7 - 1) * envelope_size;
2715
2716 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2718
2719 fidl::encoding::encode_in_envelope_optional::<BufferMemoryConstraints, D>(
2724 self.buffer_memory_constraints
2725 .as_ref()
2726 .map(<BufferMemoryConstraints as fidl::encoding::ValueTypeMarker>::borrow),
2727 encoder,
2728 offset + cur_offset,
2729 depth,
2730 )?;
2731
2732 _prev_end_offset = cur_offset + envelope_size;
2733 if 8 > max_ordinal {
2734 return Ok(());
2735 }
2736
2737 let cur_offset: usize = (8 - 1) * envelope_size;
2740
2741 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2743
2744 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ImageFormatConstraints, 64>, D>(
2749 self.image_format_constraints.as_ref().map(<fidl::encoding::Vector<ImageFormatConstraints, 64> as fidl::encoding::ValueTypeMarker>::borrow),
2750 encoder, offset + cur_offset, depth
2751 )?;
2752
2753 _prev_end_offset = cur_offset + envelope_size;
2754
2755 Ok(())
2756 }
2757 }
2758
2759 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2760 for BufferCollectionConstraints
2761 {
2762 #[inline(always)]
2763 fn new_empty() -> Self {
2764 Self::default()
2765 }
2766
2767 unsafe fn decode(
2768 &mut self,
2769 decoder: &mut fidl::encoding::Decoder<'_, D>,
2770 offset: usize,
2771 mut depth: fidl::encoding::Depth,
2772 ) -> fidl::Result<()> {
2773 decoder.debug_check_bounds::<Self>(offset);
2774 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2775 None => return Err(fidl::Error::NotNullable),
2776 Some(len) => len,
2777 };
2778 if len == 0 {
2780 return Ok(());
2781 };
2782 depth.increment()?;
2783 let envelope_size = 8;
2784 let bytes_len = len * envelope_size;
2785 let offset = decoder.out_of_line_offset(bytes_len)?;
2786 let mut _next_ordinal_to_read = 0;
2788 let mut next_offset = offset;
2789 let end_offset = offset + bytes_len;
2790 _next_ordinal_to_read += 1;
2791 if next_offset >= end_offset {
2792 return Ok(());
2793 }
2794
2795 while _next_ordinal_to_read < 1 {
2797 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2798 _next_ordinal_to_read += 1;
2799 next_offset += envelope_size;
2800 }
2801
2802 let next_out_of_line = decoder.next_out_of_line();
2803 let handles_before = decoder.remaining_handles();
2804 if let Some((inlined, num_bytes, num_handles)) =
2805 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2806 {
2807 let member_inline_size =
2808 <BufferUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2809 if inlined != (member_inline_size <= 4) {
2810 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2811 }
2812 let inner_offset;
2813 let mut inner_depth = depth.clone();
2814 if inlined {
2815 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2816 inner_offset = next_offset;
2817 } else {
2818 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2819 inner_depth.increment()?;
2820 }
2821 let val_ref = self.usage.get_or_insert_with(|| fidl::new_empty!(BufferUsage, D));
2822 fidl::decode!(BufferUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
2823 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2824 {
2825 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2826 }
2827 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2828 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2829 }
2830 }
2831
2832 next_offset += envelope_size;
2833 _next_ordinal_to_read += 1;
2834 if next_offset >= end_offset {
2835 return Ok(());
2836 }
2837
2838 while _next_ordinal_to_read < 2 {
2840 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2841 _next_ordinal_to_read += 1;
2842 next_offset += envelope_size;
2843 }
2844
2845 let next_out_of_line = decoder.next_out_of_line();
2846 let handles_before = decoder.remaining_handles();
2847 if let Some((inlined, num_bytes, num_handles)) =
2848 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2849 {
2850 let member_inline_size =
2851 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2852 if inlined != (member_inline_size <= 4) {
2853 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2854 }
2855 let inner_offset;
2856 let mut inner_depth = depth.clone();
2857 if inlined {
2858 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2859 inner_offset = next_offset;
2860 } else {
2861 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2862 inner_depth.increment()?;
2863 }
2864 let val_ref = self
2865 .min_buffer_count_for_camping
2866 .get_or_insert_with(|| fidl::new_empty!(u32, D));
2867 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2869 {
2870 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2871 }
2872 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2873 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2874 }
2875 }
2876
2877 next_offset += envelope_size;
2878 _next_ordinal_to_read += 1;
2879 if next_offset >= end_offset {
2880 return Ok(());
2881 }
2882
2883 while _next_ordinal_to_read < 3 {
2885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2886 _next_ordinal_to_read += 1;
2887 next_offset += envelope_size;
2888 }
2889
2890 let next_out_of_line = decoder.next_out_of_line();
2891 let handles_before = decoder.remaining_handles();
2892 if let Some((inlined, num_bytes, num_handles)) =
2893 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2894 {
2895 let member_inline_size =
2896 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2897 if inlined != (member_inline_size <= 4) {
2898 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2899 }
2900 let inner_offset;
2901 let mut inner_depth = depth.clone();
2902 if inlined {
2903 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2904 inner_offset = next_offset;
2905 } else {
2906 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2907 inner_depth.increment()?;
2908 }
2909 let val_ref = self
2910 .min_buffer_count_for_dedicated_slack
2911 .get_or_insert_with(|| fidl::new_empty!(u32, D));
2912 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2913 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2914 {
2915 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2916 }
2917 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2918 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2919 }
2920 }
2921
2922 next_offset += envelope_size;
2923 _next_ordinal_to_read += 1;
2924 if next_offset >= end_offset {
2925 return Ok(());
2926 }
2927
2928 while _next_ordinal_to_read < 4 {
2930 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2931 _next_ordinal_to_read += 1;
2932 next_offset += envelope_size;
2933 }
2934
2935 let next_out_of_line = decoder.next_out_of_line();
2936 let handles_before = decoder.remaining_handles();
2937 if let Some((inlined, num_bytes, num_handles)) =
2938 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2939 {
2940 let member_inline_size =
2941 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2942 if inlined != (member_inline_size <= 4) {
2943 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2944 }
2945 let inner_offset;
2946 let mut inner_depth = depth.clone();
2947 if inlined {
2948 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2949 inner_offset = next_offset;
2950 } else {
2951 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2952 inner_depth.increment()?;
2953 }
2954 let val_ref = self
2955 .min_buffer_count_for_shared_slack
2956 .get_or_insert_with(|| fidl::new_empty!(u32, D));
2957 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2958 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2959 {
2960 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2961 }
2962 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2963 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2964 }
2965 }
2966
2967 next_offset += envelope_size;
2968 _next_ordinal_to_read += 1;
2969 if next_offset >= end_offset {
2970 return Ok(());
2971 }
2972
2973 while _next_ordinal_to_read < 5 {
2975 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2976 _next_ordinal_to_read += 1;
2977 next_offset += envelope_size;
2978 }
2979
2980 let next_out_of_line = decoder.next_out_of_line();
2981 let handles_before = decoder.remaining_handles();
2982 if let Some((inlined, num_bytes, num_handles)) =
2983 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2984 {
2985 let member_inline_size =
2986 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2987 if inlined != (member_inline_size <= 4) {
2988 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2989 }
2990 let inner_offset;
2991 let mut inner_depth = depth.clone();
2992 if inlined {
2993 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2994 inner_offset = next_offset;
2995 } else {
2996 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2997 inner_depth.increment()?;
2998 }
2999 let val_ref = self.min_buffer_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
3000 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3002 {
3003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3004 }
3005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3007 }
3008 }
3009
3010 next_offset += envelope_size;
3011 _next_ordinal_to_read += 1;
3012 if next_offset >= end_offset {
3013 return Ok(());
3014 }
3015
3016 while _next_ordinal_to_read < 6 {
3018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3019 _next_ordinal_to_read += 1;
3020 next_offset += envelope_size;
3021 }
3022
3023 let next_out_of_line = decoder.next_out_of_line();
3024 let handles_before = decoder.remaining_handles();
3025 if let Some((inlined, num_bytes, num_handles)) =
3026 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3027 {
3028 let member_inline_size =
3029 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3030 if inlined != (member_inline_size <= 4) {
3031 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3032 }
3033 let inner_offset;
3034 let mut inner_depth = depth.clone();
3035 if inlined {
3036 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3037 inner_offset = next_offset;
3038 } else {
3039 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3040 inner_depth.increment()?;
3041 }
3042 let val_ref = self.max_buffer_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
3043 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3044 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3045 {
3046 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3047 }
3048 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3049 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3050 }
3051 }
3052
3053 next_offset += envelope_size;
3054 _next_ordinal_to_read += 1;
3055 if next_offset >= end_offset {
3056 return Ok(());
3057 }
3058
3059 while _next_ordinal_to_read < 7 {
3061 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3062 _next_ordinal_to_read += 1;
3063 next_offset += envelope_size;
3064 }
3065
3066 let next_out_of_line = decoder.next_out_of_line();
3067 let handles_before = decoder.remaining_handles();
3068 if let Some((inlined, num_bytes, num_handles)) =
3069 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3070 {
3071 let member_inline_size =
3072 <BufferMemoryConstraints as fidl::encoding::TypeMarker>::inline_size(
3073 decoder.context,
3074 );
3075 if inlined != (member_inline_size <= 4) {
3076 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3077 }
3078 let inner_offset;
3079 let mut inner_depth = depth.clone();
3080 if inlined {
3081 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3082 inner_offset = next_offset;
3083 } else {
3084 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3085 inner_depth.increment()?;
3086 }
3087 let val_ref = self
3088 .buffer_memory_constraints
3089 .get_or_insert_with(|| fidl::new_empty!(BufferMemoryConstraints, D));
3090 fidl::decode!(
3091 BufferMemoryConstraints,
3092 D,
3093 val_ref,
3094 decoder,
3095 inner_offset,
3096 inner_depth
3097 )?;
3098 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3099 {
3100 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3101 }
3102 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3103 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3104 }
3105 }
3106
3107 next_offset += envelope_size;
3108 _next_ordinal_to_read += 1;
3109 if next_offset >= end_offset {
3110 return Ok(());
3111 }
3112
3113 while _next_ordinal_to_read < 8 {
3115 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3116 _next_ordinal_to_read += 1;
3117 next_offset += envelope_size;
3118 }
3119
3120 let next_out_of_line = decoder.next_out_of_line();
3121 let handles_before = decoder.remaining_handles();
3122 if let Some((inlined, num_bytes, num_handles)) =
3123 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3124 {
3125 let member_inline_size = <fidl::encoding::Vector<ImageFormatConstraints, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3126 if inlined != (member_inline_size <= 4) {
3127 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3128 }
3129 let inner_offset;
3130 let mut inner_depth = depth.clone();
3131 if inlined {
3132 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3133 inner_offset = next_offset;
3134 } else {
3135 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3136 inner_depth.increment()?;
3137 }
3138 let val_ref = self.image_format_constraints.get_or_insert_with(
3139 || fidl::new_empty!(fidl::encoding::Vector<ImageFormatConstraints, 64>, D),
3140 );
3141 fidl::decode!(fidl::encoding::Vector<ImageFormatConstraints, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3142 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3143 {
3144 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3145 }
3146 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3147 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3148 }
3149 }
3150
3151 next_offset += envelope_size;
3152
3153 while next_offset < end_offset {
3155 _next_ordinal_to_read += 1;
3156 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3157 next_offset += envelope_size;
3158 }
3159
3160 Ok(())
3161 }
3162 }
3163
3164 impl BufferCollectionTokenDuplicateSyncRequest {
3165 #[inline(always)]
3166 fn max_ordinal_present(&self) -> u64 {
3167 if let Some(_) = self.rights_attenuation_masks {
3168 return 1;
3169 }
3170 0
3171 }
3172 }
3173
3174 impl fidl::encoding::ValueTypeMarker for BufferCollectionTokenDuplicateSyncRequest {
3175 type Borrowed<'a> = &'a Self;
3176 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3177 value
3178 }
3179 }
3180
3181 unsafe impl fidl::encoding::TypeMarker for BufferCollectionTokenDuplicateSyncRequest {
3182 type Owned = Self;
3183
3184 #[inline(always)]
3185 fn inline_align(_context: fidl::encoding::Context) -> usize {
3186 8
3187 }
3188
3189 #[inline(always)]
3190 fn inline_size(_context: fidl::encoding::Context) -> usize {
3191 16
3192 }
3193 }
3194
3195 unsafe impl<D: fidl::encoding::ResourceDialect>
3196 fidl::encoding::Encode<BufferCollectionTokenDuplicateSyncRequest, D>
3197 for &BufferCollectionTokenDuplicateSyncRequest
3198 {
3199 unsafe fn encode(
3200 self,
3201 encoder: &mut fidl::encoding::Encoder<'_, D>,
3202 offset: usize,
3203 mut depth: fidl::encoding::Depth,
3204 ) -> fidl::Result<()> {
3205 encoder.debug_check_bounds::<BufferCollectionTokenDuplicateSyncRequest>(offset);
3206 let max_ordinal: u64 = self.max_ordinal_present();
3208 encoder.write_num(max_ordinal, offset);
3209 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3210 if max_ordinal == 0 {
3212 return Ok(());
3213 }
3214 depth.increment()?;
3215 let envelope_size = 8;
3216 let bytes_len = max_ordinal as usize * envelope_size;
3217 #[allow(unused_variables)]
3218 let offset = encoder.out_of_line_offset(bytes_len);
3219 let mut _prev_end_offset: usize = 0;
3220 if 1 > max_ordinal {
3221 return Ok(());
3222 }
3223
3224 let cur_offset: usize = (1 - 1) * envelope_size;
3227
3228 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3230
3231 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::Rights, 64>, D>(
3236 self.rights_attenuation_masks.as_ref().map(<fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3237 encoder, offset + cur_offset, depth
3238 )?;
3239
3240 _prev_end_offset = cur_offset + envelope_size;
3241
3242 Ok(())
3243 }
3244 }
3245
3246 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3247 for BufferCollectionTokenDuplicateSyncRequest
3248 {
3249 #[inline(always)]
3250 fn new_empty() -> Self {
3251 Self::default()
3252 }
3253
3254 unsafe fn decode(
3255 &mut self,
3256 decoder: &mut fidl::encoding::Decoder<'_, D>,
3257 offset: usize,
3258 mut depth: fidl::encoding::Depth,
3259 ) -> fidl::Result<()> {
3260 decoder.debug_check_bounds::<Self>(offset);
3261 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3262 None => return Err(fidl::Error::NotNullable),
3263 Some(len) => len,
3264 };
3265 if len == 0 {
3267 return Ok(());
3268 };
3269 depth.increment()?;
3270 let envelope_size = 8;
3271 let bytes_len = len * envelope_size;
3272 let offset = decoder.out_of_line_offset(bytes_len)?;
3273 let mut _next_ordinal_to_read = 0;
3275 let mut next_offset = offset;
3276 let end_offset = offset + bytes_len;
3277 _next_ordinal_to_read += 1;
3278 if next_offset >= end_offset {
3279 return Ok(());
3280 }
3281
3282 while _next_ordinal_to_read < 1 {
3284 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3285 _next_ordinal_to_read += 1;
3286 next_offset += envelope_size;
3287 }
3288
3289 let next_out_of_line = decoder.next_out_of_line();
3290 let handles_before = decoder.remaining_handles();
3291 if let Some((inlined, num_bytes, num_handles)) =
3292 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3293 {
3294 let member_inline_size = <fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3295 if inlined != (member_inline_size <= 4) {
3296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3297 }
3298 let inner_offset;
3299 let mut inner_depth = depth.clone();
3300 if inlined {
3301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3302 inner_offset = next_offset;
3303 } else {
3304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3305 inner_depth.increment()?;
3306 }
3307 let val_ref = self.rights_attenuation_masks.get_or_insert_with(
3308 || fidl::new_empty!(fidl::encoding::Vector<fidl::Rights, 64>, D),
3309 );
3310 fidl::decode!(fidl::encoding::Vector<fidl::Rights, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3311 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3312 {
3313 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3314 }
3315 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3316 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3317 }
3318 }
3319
3320 next_offset += envelope_size;
3321
3322 while next_offset < end_offset {
3324 _next_ordinal_to_read += 1;
3325 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3326 next_offset += envelope_size;
3327 }
3328
3329 Ok(())
3330 }
3331 }
3332
3333 impl BufferCollectionTokenGroupCreateChildrenSyncRequest {
3334 #[inline(always)]
3335 fn max_ordinal_present(&self) -> u64 {
3336 if let Some(_) = self.rights_attenuation_masks {
3337 return 1;
3338 }
3339 0
3340 }
3341 }
3342
3343 impl fidl::encoding::ValueTypeMarker for BufferCollectionTokenGroupCreateChildrenSyncRequest {
3344 type Borrowed<'a> = &'a Self;
3345 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3346 value
3347 }
3348 }
3349
3350 unsafe impl fidl::encoding::TypeMarker for BufferCollectionTokenGroupCreateChildrenSyncRequest {
3351 type Owned = Self;
3352
3353 #[inline(always)]
3354 fn inline_align(_context: fidl::encoding::Context) -> usize {
3355 8
3356 }
3357
3358 #[inline(always)]
3359 fn inline_size(_context: fidl::encoding::Context) -> usize {
3360 16
3361 }
3362 }
3363
3364 unsafe impl<D: fidl::encoding::ResourceDialect>
3365 fidl::encoding::Encode<BufferCollectionTokenGroupCreateChildrenSyncRequest, D>
3366 for &BufferCollectionTokenGroupCreateChildrenSyncRequest
3367 {
3368 unsafe fn encode(
3369 self,
3370 encoder: &mut fidl::encoding::Encoder<'_, D>,
3371 offset: usize,
3372 mut depth: fidl::encoding::Depth,
3373 ) -> fidl::Result<()> {
3374 encoder
3375 .debug_check_bounds::<BufferCollectionTokenGroupCreateChildrenSyncRequest>(offset);
3376 let max_ordinal: u64 = self.max_ordinal_present();
3378 encoder.write_num(max_ordinal, offset);
3379 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3380 if max_ordinal == 0 {
3382 return Ok(());
3383 }
3384 depth.increment()?;
3385 let envelope_size = 8;
3386 let bytes_len = max_ordinal as usize * envelope_size;
3387 #[allow(unused_variables)]
3388 let offset = encoder.out_of_line_offset(bytes_len);
3389 let mut _prev_end_offset: usize = 0;
3390 if 1 > max_ordinal {
3391 return Ok(());
3392 }
3393
3394 let cur_offset: usize = (1 - 1) * envelope_size;
3397
3398 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3400
3401 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::Rights, 64>, D>(
3406 self.rights_attenuation_masks.as_ref().map(<fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3407 encoder, offset + cur_offset, depth
3408 )?;
3409
3410 _prev_end_offset = cur_offset + envelope_size;
3411
3412 Ok(())
3413 }
3414 }
3415
3416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3417 for BufferCollectionTokenGroupCreateChildrenSyncRequest
3418 {
3419 #[inline(always)]
3420 fn new_empty() -> Self {
3421 Self::default()
3422 }
3423
3424 unsafe fn decode(
3425 &mut self,
3426 decoder: &mut fidl::encoding::Decoder<'_, D>,
3427 offset: usize,
3428 mut depth: fidl::encoding::Depth,
3429 ) -> fidl::Result<()> {
3430 decoder.debug_check_bounds::<Self>(offset);
3431 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3432 None => return Err(fidl::Error::NotNullable),
3433 Some(len) => len,
3434 };
3435 if len == 0 {
3437 return Ok(());
3438 };
3439 depth.increment()?;
3440 let envelope_size = 8;
3441 let bytes_len = len * envelope_size;
3442 let offset = decoder.out_of_line_offset(bytes_len)?;
3443 let mut _next_ordinal_to_read = 0;
3445 let mut next_offset = offset;
3446 let end_offset = offset + bytes_len;
3447 _next_ordinal_to_read += 1;
3448 if next_offset >= end_offset {
3449 return Ok(());
3450 }
3451
3452 while _next_ordinal_to_read < 1 {
3454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3455 _next_ordinal_to_read += 1;
3456 next_offset += envelope_size;
3457 }
3458
3459 let next_out_of_line = decoder.next_out_of_line();
3460 let handles_before = decoder.remaining_handles();
3461 if let Some((inlined, num_bytes, num_handles)) =
3462 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3463 {
3464 let member_inline_size = <fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3465 if inlined != (member_inline_size <= 4) {
3466 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3467 }
3468 let inner_offset;
3469 let mut inner_depth = depth.clone();
3470 if inlined {
3471 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3472 inner_offset = next_offset;
3473 } else {
3474 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3475 inner_depth.increment()?;
3476 }
3477 let val_ref = self.rights_attenuation_masks.get_or_insert_with(
3478 || fidl::new_empty!(fidl::encoding::Vector<fidl::Rights, 64>, D),
3479 );
3480 fidl::decode!(fidl::encoding::Vector<fidl::Rights, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3481 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3482 {
3483 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3484 }
3485 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3486 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3487 }
3488 }
3489
3490 next_offset += envelope_size;
3491
3492 while next_offset < end_offset {
3494 _next_ordinal_to_read += 1;
3495 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3496 next_offset += envelope_size;
3497 }
3498
3499 Ok(())
3500 }
3501 }
3502
3503 impl BufferMemoryConstraints {
3504 #[inline(always)]
3505 fn max_ordinal_present(&self) -> u64 {
3506 if let Some(_) = self.permitted_heaps {
3507 return 8;
3508 }
3509 if let Some(_) = self.inaccessible_domain_supported {
3510 return 7;
3511 }
3512 if let Some(_) = self.ram_domain_supported {
3513 return 6;
3514 }
3515 if let Some(_) = self.cpu_domain_supported {
3516 return 5;
3517 }
3518 if let Some(_) = self.secure_required {
3519 return 4;
3520 }
3521 if let Some(_) = self.physically_contiguous_required {
3522 return 3;
3523 }
3524 if let Some(_) = self.max_size_bytes {
3525 return 2;
3526 }
3527 if let Some(_) = self.min_size_bytes {
3528 return 1;
3529 }
3530 0
3531 }
3532 }
3533
3534 impl fidl::encoding::ValueTypeMarker for BufferMemoryConstraints {
3535 type Borrowed<'a> = &'a Self;
3536 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3537 value
3538 }
3539 }
3540
3541 unsafe impl fidl::encoding::TypeMarker for BufferMemoryConstraints {
3542 type Owned = Self;
3543
3544 #[inline(always)]
3545 fn inline_align(_context: fidl::encoding::Context) -> usize {
3546 8
3547 }
3548
3549 #[inline(always)]
3550 fn inline_size(_context: fidl::encoding::Context) -> usize {
3551 16
3552 }
3553 }
3554
3555 unsafe impl<D: fidl::encoding::ResourceDialect>
3556 fidl::encoding::Encode<BufferMemoryConstraints, D> for &BufferMemoryConstraints
3557 {
3558 unsafe fn encode(
3559 self,
3560 encoder: &mut fidl::encoding::Encoder<'_, D>,
3561 offset: usize,
3562 mut depth: fidl::encoding::Depth,
3563 ) -> fidl::Result<()> {
3564 encoder.debug_check_bounds::<BufferMemoryConstraints>(offset);
3565 let max_ordinal: u64 = self.max_ordinal_present();
3567 encoder.write_num(max_ordinal, offset);
3568 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3569 if max_ordinal == 0 {
3571 return Ok(());
3572 }
3573 depth.increment()?;
3574 let envelope_size = 8;
3575 let bytes_len = max_ordinal as usize * envelope_size;
3576 #[allow(unused_variables)]
3577 let offset = encoder.out_of_line_offset(bytes_len);
3578 let mut _prev_end_offset: usize = 0;
3579 if 1 > max_ordinal {
3580 return Ok(());
3581 }
3582
3583 let cur_offset: usize = (1 - 1) * envelope_size;
3586
3587 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3589
3590 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3595 self.min_size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3596 encoder,
3597 offset + cur_offset,
3598 depth,
3599 )?;
3600
3601 _prev_end_offset = cur_offset + envelope_size;
3602 if 2 > max_ordinal {
3603 return Ok(());
3604 }
3605
3606 let cur_offset: usize = (2 - 1) * envelope_size;
3609
3610 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3612
3613 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3618 self.max_size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3619 encoder,
3620 offset + cur_offset,
3621 depth,
3622 )?;
3623
3624 _prev_end_offset = cur_offset + envelope_size;
3625 if 3 > max_ordinal {
3626 return Ok(());
3627 }
3628
3629 let cur_offset: usize = (3 - 1) * envelope_size;
3632
3633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3635
3636 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3641 self.physically_contiguous_required
3642 .as_ref()
3643 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3644 encoder,
3645 offset + cur_offset,
3646 depth,
3647 )?;
3648
3649 _prev_end_offset = cur_offset + envelope_size;
3650 if 4 > max_ordinal {
3651 return Ok(());
3652 }
3653
3654 let cur_offset: usize = (4 - 1) * envelope_size;
3657
3658 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3660
3661 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3666 self.secure_required
3667 .as_ref()
3668 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3669 encoder,
3670 offset + cur_offset,
3671 depth,
3672 )?;
3673
3674 _prev_end_offset = cur_offset + envelope_size;
3675 if 5 > max_ordinal {
3676 return Ok(());
3677 }
3678
3679 let cur_offset: usize = (5 - 1) * envelope_size;
3682
3683 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3685
3686 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3691 self.cpu_domain_supported
3692 .as_ref()
3693 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3694 encoder,
3695 offset + cur_offset,
3696 depth,
3697 )?;
3698
3699 _prev_end_offset = cur_offset + envelope_size;
3700 if 6 > max_ordinal {
3701 return Ok(());
3702 }
3703
3704 let cur_offset: usize = (6 - 1) * envelope_size;
3707
3708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3710
3711 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3716 self.ram_domain_supported
3717 .as_ref()
3718 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3719 encoder,
3720 offset + cur_offset,
3721 depth,
3722 )?;
3723
3724 _prev_end_offset = cur_offset + envelope_size;
3725 if 7 > max_ordinal {
3726 return Ok(());
3727 }
3728
3729 let cur_offset: usize = (7 - 1) * envelope_size;
3732
3733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3735
3736 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3741 self.inaccessible_domain_supported
3742 .as_ref()
3743 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3744 encoder,
3745 offset + cur_offset,
3746 depth,
3747 )?;
3748
3749 _prev_end_offset = cur_offset + envelope_size;
3750 if 8 > max_ordinal {
3751 return Ok(());
3752 }
3753
3754 let cur_offset: usize = (8 - 1) * envelope_size;
3757
3758 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3760
3761 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Heap, 64>, D>(
3766 self.permitted_heaps.as_ref().map(
3767 <fidl::encoding::Vector<Heap, 64> as fidl::encoding::ValueTypeMarker>::borrow,
3768 ),
3769 encoder,
3770 offset + cur_offset,
3771 depth,
3772 )?;
3773
3774 _prev_end_offset = cur_offset + envelope_size;
3775
3776 Ok(())
3777 }
3778 }
3779
3780 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3781 for BufferMemoryConstraints
3782 {
3783 #[inline(always)]
3784 fn new_empty() -> Self {
3785 Self::default()
3786 }
3787
3788 unsafe fn decode(
3789 &mut self,
3790 decoder: &mut fidl::encoding::Decoder<'_, D>,
3791 offset: usize,
3792 mut depth: fidl::encoding::Depth,
3793 ) -> fidl::Result<()> {
3794 decoder.debug_check_bounds::<Self>(offset);
3795 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3796 None => return Err(fidl::Error::NotNullable),
3797 Some(len) => len,
3798 };
3799 if len == 0 {
3801 return Ok(());
3802 };
3803 depth.increment()?;
3804 let envelope_size = 8;
3805 let bytes_len = len * envelope_size;
3806 let offset = decoder.out_of_line_offset(bytes_len)?;
3807 let mut _next_ordinal_to_read = 0;
3809 let mut next_offset = offset;
3810 let end_offset = offset + bytes_len;
3811 _next_ordinal_to_read += 1;
3812 if next_offset >= end_offset {
3813 return Ok(());
3814 }
3815
3816 while _next_ordinal_to_read < 1 {
3818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3819 _next_ordinal_to_read += 1;
3820 next_offset += envelope_size;
3821 }
3822
3823 let next_out_of_line = decoder.next_out_of_line();
3824 let handles_before = decoder.remaining_handles();
3825 if let Some((inlined, num_bytes, num_handles)) =
3826 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3827 {
3828 let member_inline_size =
3829 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3830 if inlined != (member_inline_size <= 4) {
3831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3832 }
3833 let inner_offset;
3834 let mut inner_depth = depth.clone();
3835 if inlined {
3836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3837 inner_offset = next_offset;
3838 } else {
3839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3840 inner_depth.increment()?;
3841 }
3842 let val_ref = self.min_size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3843 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3845 {
3846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3847 }
3848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3850 }
3851 }
3852
3853 next_offset += envelope_size;
3854 _next_ordinal_to_read += 1;
3855 if next_offset >= end_offset {
3856 return Ok(());
3857 }
3858
3859 while _next_ordinal_to_read < 2 {
3861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3862 _next_ordinal_to_read += 1;
3863 next_offset += envelope_size;
3864 }
3865
3866 let next_out_of_line = decoder.next_out_of_line();
3867 let handles_before = decoder.remaining_handles();
3868 if let Some((inlined, num_bytes, num_handles)) =
3869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3870 {
3871 let member_inline_size =
3872 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3873 if inlined != (member_inline_size <= 4) {
3874 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3875 }
3876 let inner_offset;
3877 let mut inner_depth = depth.clone();
3878 if inlined {
3879 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3880 inner_offset = next_offset;
3881 } else {
3882 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3883 inner_depth.increment()?;
3884 }
3885 let val_ref = self.max_size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3886 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3888 {
3889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3890 }
3891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3893 }
3894 }
3895
3896 next_offset += envelope_size;
3897 _next_ordinal_to_read += 1;
3898 if next_offset >= end_offset {
3899 return Ok(());
3900 }
3901
3902 while _next_ordinal_to_read < 3 {
3904 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3905 _next_ordinal_to_read += 1;
3906 next_offset += envelope_size;
3907 }
3908
3909 let next_out_of_line = decoder.next_out_of_line();
3910 let handles_before = decoder.remaining_handles();
3911 if let Some((inlined, num_bytes, num_handles)) =
3912 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3913 {
3914 let member_inline_size =
3915 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3916 if inlined != (member_inline_size <= 4) {
3917 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3918 }
3919 let inner_offset;
3920 let mut inner_depth = depth.clone();
3921 if inlined {
3922 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3923 inner_offset = next_offset;
3924 } else {
3925 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3926 inner_depth.increment()?;
3927 }
3928 let val_ref = self
3929 .physically_contiguous_required
3930 .get_or_insert_with(|| fidl::new_empty!(bool, D));
3931 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3932 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3933 {
3934 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3935 }
3936 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3937 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3938 }
3939 }
3940
3941 next_offset += envelope_size;
3942 _next_ordinal_to_read += 1;
3943 if next_offset >= end_offset {
3944 return Ok(());
3945 }
3946
3947 while _next_ordinal_to_read < 4 {
3949 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3950 _next_ordinal_to_read += 1;
3951 next_offset += envelope_size;
3952 }
3953
3954 let next_out_of_line = decoder.next_out_of_line();
3955 let handles_before = decoder.remaining_handles();
3956 if let Some((inlined, num_bytes, num_handles)) =
3957 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3958 {
3959 let member_inline_size =
3960 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3961 if inlined != (member_inline_size <= 4) {
3962 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3963 }
3964 let inner_offset;
3965 let mut inner_depth = depth.clone();
3966 if inlined {
3967 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3968 inner_offset = next_offset;
3969 } else {
3970 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3971 inner_depth.increment()?;
3972 }
3973 let val_ref = self.secure_required.get_or_insert_with(|| fidl::new_empty!(bool, D));
3974 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3975 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3976 {
3977 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3978 }
3979 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3980 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3981 }
3982 }
3983
3984 next_offset += envelope_size;
3985 _next_ordinal_to_read += 1;
3986 if next_offset >= end_offset {
3987 return Ok(());
3988 }
3989
3990 while _next_ordinal_to_read < 5 {
3992 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3993 _next_ordinal_to_read += 1;
3994 next_offset += envelope_size;
3995 }
3996
3997 let next_out_of_line = decoder.next_out_of_line();
3998 let handles_before = decoder.remaining_handles();
3999 if let Some((inlined, num_bytes, num_handles)) =
4000 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4001 {
4002 let member_inline_size =
4003 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4004 if inlined != (member_inline_size <= 4) {
4005 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4006 }
4007 let inner_offset;
4008 let mut inner_depth = depth.clone();
4009 if inlined {
4010 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4011 inner_offset = next_offset;
4012 } else {
4013 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4014 inner_depth.increment()?;
4015 }
4016 let val_ref =
4017 self.cpu_domain_supported.get_or_insert_with(|| fidl::new_empty!(bool, D));
4018 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4019 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4020 {
4021 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4022 }
4023 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4024 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4025 }
4026 }
4027
4028 next_offset += envelope_size;
4029 _next_ordinal_to_read += 1;
4030 if next_offset >= end_offset {
4031 return Ok(());
4032 }
4033
4034 while _next_ordinal_to_read < 6 {
4036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4037 _next_ordinal_to_read += 1;
4038 next_offset += envelope_size;
4039 }
4040
4041 let next_out_of_line = decoder.next_out_of_line();
4042 let handles_before = decoder.remaining_handles();
4043 if let Some((inlined, num_bytes, num_handles)) =
4044 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4045 {
4046 let member_inline_size =
4047 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4048 if inlined != (member_inline_size <= 4) {
4049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4050 }
4051 let inner_offset;
4052 let mut inner_depth = depth.clone();
4053 if inlined {
4054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4055 inner_offset = next_offset;
4056 } else {
4057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4058 inner_depth.increment()?;
4059 }
4060 let val_ref =
4061 self.ram_domain_supported.get_or_insert_with(|| fidl::new_empty!(bool, D));
4062 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4063 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4064 {
4065 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4066 }
4067 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4068 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4069 }
4070 }
4071
4072 next_offset += envelope_size;
4073 _next_ordinal_to_read += 1;
4074 if next_offset >= end_offset {
4075 return Ok(());
4076 }
4077
4078 while _next_ordinal_to_read < 7 {
4080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4081 _next_ordinal_to_read += 1;
4082 next_offset += envelope_size;
4083 }
4084
4085 let next_out_of_line = decoder.next_out_of_line();
4086 let handles_before = decoder.remaining_handles();
4087 if let Some((inlined, num_bytes, num_handles)) =
4088 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4089 {
4090 let member_inline_size =
4091 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4092 if inlined != (member_inline_size <= 4) {
4093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4094 }
4095 let inner_offset;
4096 let mut inner_depth = depth.clone();
4097 if inlined {
4098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4099 inner_offset = next_offset;
4100 } else {
4101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4102 inner_depth.increment()?;
4103 }
4104 let val_ref = self
4105 .inaccessible_domain_supported
4106 .get_or_insert_with(|| fidl::new_empty!(bool, D));
4107 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4108 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4109 {
4110 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4111 }
4112 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4113 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4114 }
4115 }
4116
4117 next_offset += envelope_size;
4118 _next_ordinal_to_read += 1;
4119 if next_offset >= end_offset {
4120 return Ok(());
4121 }
4122
4123 while _next_ordinal_to_read < 8 {
4125 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4126 _next_ordinal_to_read += 1;
4127 next_offset += envelope_size;
4128 }
4129
4130 let next_out_of_line = decoder.next_out_of_line();
4131 let handles_before = decoder.remaining_handles();
4132 if let Some((inlined, num_bytes, num_handles)) =
4133 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4134 {
4135 let member_inline_size =
4136 <fidl::encoding::Vector<Heap, 64> as fidl::encoding::TypeMarker>::inline_size(
4137 decoder.context,
4138 );
4139 if inlined != (member_inline_size <= 4) {
4140 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4141 }
4142 let inner_offset;
4143 let mut inner_depth = depth.clone();
4144 if inlined {
4145 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4146 inner_offset = next_offset;
4147 } else {
4148 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4149 inner_depth.increment()?;
4150 }
4151 let val_ref = self
4152 .permitted_heaps
4153 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Heap, 64>, D));
4154 fidl::decode!(fidl::encoding::Vector<Heap, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4155 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4156 {
4157 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4158 }
4159 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4160 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4161 }
4162 }
4163
4164 next_offset += envelope_size;
4165
4166 while next_offset < end_offset {
4168 _next_ordinal_to_read += 1;
4169 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4170 next_offset += envelope_size;
4171 }
4172
4173 Ok(())
4174 }
4175 }
4176
4177 impl BufferMemorySettings {
4178 #[inline(always)]
4179 fn max_ordinal_present(&self) -> u64 {
4180 if let Some(_) = self.heap {
4181 return 5;
4182 }
4183 if let Some(_) = self.coherency_domain {
4184 return 4;
4185 }
4186 if let Some(_) = self.is_secure {
4187 return 3;
4188 }
4189 if let Some(_) = self.is_physically_contiguous {
4190 return 2;
4191 }
4192 if let Some(_) = self.size_bytes {
4193 return 1;
4194 }
4195 0
4196 }
4197 }
4198
4199 impl fidl::encoding::ValueTypeMarker for BufferMemorySettings {
4200 type Borrowed<'a> = &'a Self;
4201 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4202 value
4203 }
4204 }
4205
4206 unsafe impl fidl::encoding::TypeMarker for BufferMemorySettings {
4207 type Owned = Self;
4208
4209 #[inline(always)]
4210 fn inline_align(_context: fidl::encoding::Context) -> usize {
4211 8
4212 }
4213
4214 #[inline(always)]
4215 fn inline_size(_context: fidl::encoding::Context) -> usize {
4216 16
4217 }
4218 }
4219
4220 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BufferMemorySettings, D>
4221 for &BufferMemorySettings
4222 {
4223 unsafe fn encode(
4224 self,
4225 encoder: &mut fidl::encoding::Encoder<'_, D>,
4226 offset: usize,
4227 mut depth: fidl::encoding::Depth,
4228 ) -> fidl::Result<()> {
4229 encoder.debug_check_bounds::<BufferMemorySettings>(offset);
4230 let max_ordinal: u64 = self.max_ordinal_present();
4232 encoder.write_num(max_ordinal, offset);
4233 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4234 if max_ordinal == 0 {
4236 return Ok(());
4237 }
4238 depth.increment()?;
4239 let envelope_size = 8;
4240 let bytes_len = max_ordinal as usize * envelope_size;
4241 #[allow(unused_variables)]
4242 let offset = encoder.out_of_line_offset(bytes_len);
4243 let mut _prev_end_offset: usize = 0;
4244 if 1 > max_ordinal {
4245 return Ok(());
4246 }
4247
4248 let cur_offset: usize = (1 - 1) * envelope_size;
4251
4252 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4254
4255 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4260 self.size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4261 encoder,
4262 offset + cur_offset,
4263 depth,
4264 )?;
4265
4266 _prev_end_offset = cur_offset + envelope_size;
4267 if 2 > max_ordinal {
4268 return Ok(());
4269 }
4270
4271 let cur_offset: usize = (2 - 1) * envelope_size;
4274
4275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4277
4278 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4283 self.is_physically_contiguous
4284 .as_ref()
4285 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4286 encoder,
4287 offset + cur_offset,
4288 depth,
4289 )?;
4290
4291 _prev_end_offset = cur_offset + envelope_size;
4292 if 3 > max_ordinal {
4293 return Ok(());
4294 }
4295
4296 let cur_offset: usize = (3 - 1) * envelope_size;
4299
4300 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4302
4303 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4308 self.is_secure.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4309 encoder,
4310 offset + cur_offset,
4311 depth,
4312 )?;
4313
4314 _prev_end_offset = cur_offset + envelope_size;
4315 if 4 > max_ordinal {
4316 return Ok(());
4317 }
4318
4319 let cur_offset: usize = (4 - 1) * envelope_size;
4322
4323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4325
4326 fidl::encoding::encode_in_envelope_optional::<CoherencyDomain, D>(
4331 self.coherency_domain
4332 .as_ref()
4333 .map(<CoherencyDomain as fidl::encoding::ValueTypeMarker>::borrow),
4334 encoder,
4335 offset + cur_offset,
4336 depth,
4337 )?;
4338
4339 _prev_end_offset = cur_offset + envelope_size;
4340 if 5 > max_ordinal {
4341 return Ok(());
4342 }
4343
4344 let cur_offset: usize = (5 - 1) * envelope_size;
4347
4348 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4350
4351 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
4356 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
4357 encoder,
4358 offset + cur_offset,
4359 depth,
4360 )?;
4361
4362 _prev_end_offset = cur_offset + envelope_size;
4363
4364 Ok(())
4365 }
4366 }
4367
4368 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferMemorySettings {
4369 #[inline(always)]
4370 fn new_empty() -> Self {
4371 Self::default()
4372 }
4373
4374 unsafe fn decode(
4375 &mut self,
4376 decoder: &mut fidl::encoding::Decoder<'_, D>,
4377 offset: usize,
4378 mut depth: fidl::encoding::Depth,
4379 ) -> fidl::Result<()> {
4380 decoder.debug_check_bounds::<Self>(offset);
4381 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4382 None => return Err(fidl::Error::NotNullable),
4383 Some(len) => len,
4384 };
4385 if len == 0 {
4387 return Ok(());
4388 };
4389 depth.increment()?;
4390 let envelope_size = 8;
4391 let bytes_len = len * envelope_size;
4392 let offset = decoder.out_of_line_offset(bytes_len)?;
4393 let mut _next_ordinal_to_read = 0;
4395 let mut next_offset = offset;
4396 let end_offset = offset + bytes_len;
4397 _next_ordinal_to_read += 1;
4398 if next_offset >= end_offset {
4399 return Ok(());
4400 }
4401
4402 while _next_ordinal_to_read < 1 {
4404 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4405 _next_ordinal_to_read += 1;
4406 next_offset += envelope_size;
4407 }
4408
4409 let next_out_of_line = decoder.next_out_of_line();
4410 let handles_before = decoder.remaining_handles();
4411 if let Some((inlined, num_bytes, num_handles)) =
4412 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4413 {
4414 let member_inline_size =
4415 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4416 if inlined != (member_inline_size <= 4) {
4417 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4418 }
4419 let inner_offset;
4420 let mut inner_depth = depth.clone();
4421 if inlined {
4422 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4423 inner_offset = next_offset;
4424 } else {
4425 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4426 inner_depth.increment()?;
4427 }
4428 let val_ref = self.size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4429 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4430 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4431 {
4432 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4433 }
4434 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4435 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4436 }
4437 }
4438
4439 next_offset += envelope_size;
4440 _next_ordinal_to_read += 1;
4441 if next_offset >= end_offset {
4442 return Ok(());
4443 }
4444
4445 while _next_ordinal_to_read < 2 {
4447 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4448 _next_ordinal_to_read += 1;
4449 next_offset += envelope_size;
4450 }
4451
4452 let next_out_of_line = decoder.next_out_of_line();
4453 let handles_before = decoder.remaining_handles();
4454 if let Some((inlined, num_bytes, num_handles)) =
4455 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4456 {
4457 let member_inline_size =
4458 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4459 if inlined != (member_inline_size <= 4) {
4460 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4461 }
4462 let inner_offset;
4463 let mut inner_depth = depth.clone();
4464 if inlined {
4465 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4466 inner_offset = next_offset;
4467 } else {
4468 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4469 inner_depth.increment()?;
4470 }
4471 let val_ref =
4472 self.is_physically_contiguous.get_or_insert_with(|| fidl::new_empty!(bool, D));
4473 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4475 {
4476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4477 }
4478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4480 }
4481 }
4482
4483 next_offset += envelope_size;
4484 _next_ordinal_to_read += 1;
4485 if next_offset >= end_offset {
4486 return Ok(());
4487 }
4488
4489 while _next_ordinal_to_read < 3 {
4491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4492 _next_ordinal_to_read += 1;
4493 next_offset += envelope_size;
4494 }
4495
4496 let next_out_of_line = decoder.next_out_of_line();
4497 let handles_before = decoder.remaining_handles();
4498 if let Some((inlined, num_bytes, num_handles)) =
4499 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4500 {
4501 let member_inline_size =
4502 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4503 if inlined != (member_inline_size <= 4) {
4504 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4505 }
4506 let inner_offset;
4507 let mut inner_depth = depth.clone();
4508 if inlined {
4509 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4510 inner_offset = next_offset;
4511 } else {
4512 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4513 inner_depth.increment()?;
4514 }
4515 let val_ref = self.is_secure.get_or_insert_with(|| fidl::new_empty!(bool, D));
4516 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4517 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4518 {
4519 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4520 }
4521 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4522 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4523 }
4524 }
4525
4526 next_offset += envelope_size;
4527 _next_ordinal_to_read += 1;
4528 if next_offset >= end_offset {
4529 return Ok(());
4530 }
4531
4532 while _next_ordinal_to_read < 4 {
4534 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4535 _next_ordinal_to_read += 1;
4536 next_offset += envelope_size;
4537 }
4538
4539 let next_out_of_line = decoder.next_out_of_line();
4540 let handles_before = decoder.remaining_handles();
4541 if let Some((inlined, num_bytes, num_handles)) =
4542 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4543 {
4544 let member_inline_size =
4545 <CoherencyDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4546 if inlined != (member_inline_size <= 4) {
4547 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4548 }
4549 let inner_offset;
4550 let mut inner_depth = depth.clone();
4551 if inlined {
4552 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4553 inner_offset = next_offset;
4554 } else {
4555 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4556 inner_depth.increment()?;
4557 }
4558 let val_ref = self
4559 .coherency_domain
4560 .get_or_insert_with(|| fidl::new_empty!(CoherencyDomain, D));
4561 fidl::decode!(CoherencyDomain, D, val_ref, decoder, inner_offset, inner_depth)?;
4562 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4563 {
4564 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4565 }
4566 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4567 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4568 }
4569 }
4570
4571 next_offset += envelope_size;
4572 _next_ordinal_to_read += 1;
4573 if next_offset >= end_offset {
4574 return Ok(());
4575 }
4576
4577 while _next_ordinal_to_read < 5 {
4579 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4580 _next_ordinal_to_read += 1;
4581 next_offset += envelope_size;
4582 }
4583
4584 let next_out_of_line = decoder.next_out_of_line();
4585 let handles_before = decoder.remaining_handles();
4586 if let Some((inlined, num_bytes, num_handles)) =
4587 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4588 {
4589 let member_inline_size =
4590 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4591 if inlined != (member_inline_size <= 4) {
4592 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4593 }
4594 let inner_offset;
4595 let mut inner_depth = depth.clone();
4596 if inlined {
4597 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4598 inner_offset = next_offset;
4599 } else {
4600 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4601 inner_depth.increment()?;
4602 }
4603 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
4604 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
4605 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4606 {
4607 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4608 }
4609 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4610 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4611 }
4612 }
4613
4614 next_offset += envelope_size;
4615
4616 while next_offset < end_offset {
4618 _next_ordinal_to_read += 1;
4619 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4620 next_offset += envelope_size;
4621 }
4622
4623 Ok(())
4624 }
4625 }
4626
4627 impl BufferUsage {
4628 #[inline(always)]
4629 fn max_ordinal_present(&self) -> u64 {
4630 if let Some(_) = self.video {
4631 return 5;
4632 }
4633 if let Some(_) = self.display {
4634 return 4;
4635 }
4636 if let Some(_) = self.vulkan {
4637 return 3;
4638 }
4639 if let Some(_) = self.cpu {
4640 return 2;
4641 }
4642 if let Some(_) = self.none {
4643 return 1;
4644 }
4645 0
4646 }
4647 }
4648
4649 impl fidl::encoding::ValueTypeMarker for BufferUsage {
4650 type Borrowed<'a> = &'a Self;
4651 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4652 value
4653 }
4654 }
4655
4656 unsafe impl fidl::encoding::TypeMarker for BufferUsage {
4657 type Owned = Self;
4658
4659 #[inline(always)]
4660 fn inline_align(_context: fidl::encoding::Context) -> usize {
4661 8
4662 }
4663
4664 #[inline(always)]
4665 fn inline_size(_context: fidl::encoding::Context) -> usize {
4666 16
4667 }
4668 }
4669
4670 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BufferUsage, D>
4671 for &BufferUsage
4672 {
4673 unsafe fn encode(
4674 self,
4675 encoder: &mut fidl::encoding::Encoder<'_, D>,
4676 offset: usize,
4677 mut depth: fidl::encoding::Depth,
4678 ) -> fidl::Result<()> {
4679 encoder.debug_check_bounds::<BufferUsage>(offset);
4680 let max_ordinal: u64 = self.max_ordinal_present();
4682 encoder.write_num(max_ordinal, offset);
4683 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4684 if max_ordinal == 0 {
4686 return Ok(());
4687 }
4688 depth.increment()?;
4689 let envelope_size = 8;
4690 let bytes_len = max_ordinal as usize * envelope_size;
4691 #[allow(unused_variables)]
4692 let offset = encoder.out_of_line_offset(bytes_len);
4693 let mut _prev_end_offset: usize = 0;
4694 if 1 > max_ordinal {
4695 return Ok(());
4696 }
4697
4698 let cur_offset: usize = (1 - 1) * envelope_size;
4701
4702 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4704
4705 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4710 self.none.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4711 encoder,
4712 offset + cur_offset,
4713 depth,
4714 )?;
4715
4716 _prev_end_offset = cur_offset + envelope_size;
4717 if 2 > max_ordinal {
4718 return Ok(());
4719 }
4720
4721 let cur_offset: usize = (2 - 1) * envelope_size;
4724
4725 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4727
4728 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4733 self.cpu.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4734 encoder,
4735 offset + cur_offset,
4736 depth,
4737 )?;
4738
4739 _prev_end_offset = cur_offset + envelope_size;
4740 if 3 > max_ordinal {
4741 return Ok(());
4742 }
4743
4744 let cur_offset: usize = (3 - 1) * envelope_size;
4747
4748 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4750
4751 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4756 self.vulkan.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4757 encoder,
4758 offset + cur_offset,
4759 depth,
4760 )?;
4761
4762 _prev_end_offset = cur_offset + envelope_size;
4763 if 4 > max_ordinal {
4764 return Ok(());
4765 }
4766
4767 let cur_offset: usize = (4 - 1) * envelope_size;
4770
4771 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4773
4774 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4779 self.display.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4780 encoder,
4781 offset + cur_offset,
4782 depth,
4783 )?;
4784
4785 _prev_end_offset = cur_offset + envelope_size;
4786 if 5 > max_ordinal {
4787 return Ok(());
4788 }
4789
4790 let cur_offset: usize = (5 - 1) * envelope_size;
4793
4794 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4796
4797 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4802 self.video.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4803 encoder,
4804 offset + cur_offset,
4805 depth,
4806 )?;
4807
4808 _prev_end_offset = cur_offset + envelope_size;
4809
4810 Ok(())
4811 }
4812 }
4813
4814 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferUsage {
4815 #[inline(always)]
4816 fn new_empty() -> Self {
4817 Self::default()
4818 }
4819
4820 unsafe fn decode(
4821 &mut self,
4822 decoder: &mut fidl::encoding::Decoder<'_, D>,
4823 offset: usize,
4824 mut depth: fidl::encoding::Depth,
4825 ) -> fidl::Result<()> {
4826 decoder.debug_check_bounds::<Self>(offset);
4827 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4828 None => return Err(fidl::Error::NotNullable),
4829 Some(len) => len,
4830 };
4831 if len == 0 {
4833 return Ok(());
4834 };
4835 depth.increment()?;
4836 let envelope_size = 8;
4837 let bytes_len = len * envelope_size;
4838 let offset = decoder.out_of_line_offset(bytes_len)?;
4839 let mut _next_ordinal_to_read = 0;
4841 let mut next_offset = offset;
4842 let end_offset = offset + bytes_len;
4843 _next_ordinal_to_read += 1;
4844 if next_offset >= end_offset {
4845 return Ok(());
4846 }
4847
4848 while _next_ordinal_to_read < 1 {
4850 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4851 _next_ordinal_to_read += 1;
4852 next_offset += envelope_size;
4853 }
4854
4855 let next_out_of_line = decoder.next_out_of_line();
4856 let handles_before = decoder.remaining_handles();
4857 if let Some((inlined, num_bytes, num_handles)) =
4858 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4859 {
4860 let member_inline_size =
4861 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4862 if inlined != (member_inline_size <= 4) {
4863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4864 }
4865 let inner_offset;
4866 let mut inner_depth = depth.clone();
4867 if inlined {
4868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4869 inner_offset = next_offset;
4870 } else {
4871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4872 inner_depth.increment()?;
4873 }
4874 let val_ref = self.none.get_or_insert_with(|| fidl::new_empty!(u32, D));
4875 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4876 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4877 {
4878 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4879 }
4880 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4881 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4882 }
4883 }
4884
4885 next_offset += envelope_size;
4886 _next_ordinal_to_read += 1;
4887 if next_offset >= end_offset {
4888 return Ok(());
4889 }
4890
4891 while _next_ordinal_to_read < 2 {
4893 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4894 _next_ordinal_to_read += 1;
4895 next_offset += envelope_size;
4896 }
4897
4898 let next_out_of_line = decoder.next_out_of_line();
4899 let handles_before = decoder.remaining_handles();
4900 if let Some((inlined, num_bytes, num_handles)) =
4901 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4902 {
4903 let member_inline_size =
4904 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4905 if inlined != (member_inline_size <= 4) {
4906 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4907 }
4908 let inner_offset;
4909 let mut inner_depth = depth.clone();
4910 if inlined {
4911 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4912 inner_offset = next_offset;
4913 } else {
4914 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4915 inner_depth.increment()?;
4916 }
4917 let val_ref = self.cpu.get_or_insert_with(|| fidl::new_empty!(u32, D));
4918 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4919 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4920 {
4921 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4922 }
4923 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4924 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4925 }
4926 }
4927
4928 next_offset += envelope_size;
4929 _next_ordinal_to_read += 1;
4930 if next_offset >= end_offset {
4931 return Ok(());
4932 }
4933
4934 while _next_ordinal_to_read < 3 {
4936 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4937 _next_ordinal_to_read += 1;
4938 next_offset += envelope_size;
4939 }
4940
4941 let next_out_of_line = decoder.next_out_of_line();
4942 let handles_before = decoder.remaining_handles();
4943 if let Some((inlined, num_bytes, num_handles)) =
4944 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4945 {
4946 let member_inline_size =
4947 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4948 if inlined != (member_inline_size <= 4) {
4949 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4950 }
4951 let inner_offset;
4952 let mut inner_depth = depth.clone();
4953 if inlined {
4954 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4955 inner_offset = next_offset;
4956 } else {
4957 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4958 inner_depth.increment()?;
4959 }
4960 let val_ref = self.vulkan.get_or_insert_with(|| fidl::new_empty!(u32, D));
4961 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4963 {
4964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4965 }
4966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4968 }
4969 }
4970
4971 next_offset += envelope_size;
4972 _next_ordinal_to_read += 1;
4973 if next_offset >= end_offset {
4974 return Ok(());
4975 }
4976
4977 while _next_ordinal_to_read < 4 {
4979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4980 _next_ordinal_to_read += 1;
4981 next_offset += envelope_size;
4982 }
4983
4984 let next_out_of_line = decoder.next_out_of_line();
4985 let handles_before = decoder.remaining_handles();
4986 if let Some((inlined, num_bytes, num_handles)) =
4987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4988 {
4989 let member_inline_size =
4990 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4991 if inlined != (member_inline_size <= 4) {
4992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4993 }
4994 let inner_offset;
4995 let mut inner_depth = depth.clone();
4996 if inlined {
4997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4998 inner_offset = next_offset;
4999 } else {
5000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5001 inner_depth.increment()?;
5002 }
5003 let val_ref = self.display.get_or_insert_with(|| fidl::new_empty!(u32, D));
5004 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5006 {
5007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5008 }
5009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5011 }
5012 }
5013
5014 next_offset += envelope_size;
5015 _next_ordinal_to_read += 1;
5016 if next_offset >= end_offset {
5017 return Ok(());
5018 }
5019
5020 while _next_ordinal_to_read < 5 {
5022 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5023 _next_ordinal_to_read += 1;
5024 next_offset += envelope_size;
5025 }
5026
5027 let next_out_of_line = decoder.next_out_of_line();
5028 let handles_before = decoder.remaining_handles();
5029 if let Some((inlined, num_bytes, num_handles)) =
5030 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5031 {
5032 let member_inline_size =
5033 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5034 if inlined != (member_inline_size <= 4) {
5035 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5036 }
5037 let inner_offset;
5038 let mut inner_depth = depth.clone();
5039 if inlined {
5040 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5041 inner_offset = next_offset;
5042 } else {
5043 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5044 inner_depth.increment()?;
5045 }
5046 let val_ref = self.video.get_or_insert_with(|| fidl::new_empty!(u32, D));
5047 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5048 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5049 {
5050 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5051 }
5052 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5053 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5054 }
5055 }
5056
5057 next_offset += envelope_size;
5058
5059 while next_offset < end_offset {
5061 _next_ordinal_to_read += 1;
5062 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5063 next_offset += envelope_size;
5064 }
5065
5066 Ok(())
5067 }
5068 }
5069
5070 impl Config {
5071 #[inline(always)]
5072 fn max_ordinal_present(&self) -> u64 {
5073 if let Some(_) = self.format_costs {
5074 return 1;
5075 }
5076 0
5077 }
5078 }
5079
5080 impl fidl::encoding::ValueTypeMarker for Config {
5081 type Borrowed<'a> = &'a Self;
5082 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5083 value
5084 }
5085 }
5086
5087 unsafe impl fidl::encoding::TypeMarker for Config {
5088 type Owned = Self;
5089
5090 #[inline(always)]
5091 fn inline_align(_context: fidl::encoding::Context) -> usize {
5092 8
5093 }
5094
5095 #[inline(always)]
5096 fn inline_size(_context: fidl::encoding::Context) -> usize {
5097 16
5098 }
5099 }
5100
5101 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
5102 unsafe fn encode(
5103 self,
5104 encoder: &mut fidl::encoding::Encoder<'_, D>,
5105 offset: usize,
5106 mut depth: fidl::encoding::Depth,
5107 ) -> fidl::Result<()> {
5108 encoder.debug_check_bounds::<Config>(offset);
5109 let max_ordinal: u64 = self.max_ordinal_present();
5111 encoder.write_num(max_ordinal, offset);
5112 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5113 if max_ordinal == 0 {
5115 return Ok(());
5116 }
5117 depth.increment()?;
5118 let envelope_size = 8;
5119 let bytes_len = max_ordinal as usize * envelope_size;
5120 #[allow(unused_variables)]
5121 let offset = encoder.out_of_line_offset(bytes_len);
5122 let mut _prev_end_offset: usize = 0;
5123 if 1 > max_ordinal {
5124 return Ok(());
5125 }
5126
5127 let cur_offset: usize = (1 - 1) * envelope_size;
5130
5131 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5133
5134 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<FormatCostEntry>, D>(
5139 self.format_costs.as_ref().map(<fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::ValueTypeMarker>::borrow),
5140 encoder, offset + cur_offset, depth
5141 )?;
5142
5143 _prev_end_offset = cur_offset + envelope_size;
5144
5145 Ok(())
5146 }
5147 }
5148
5149 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
5150 #[inline(always)]
5151 fn new_empty() -> Self {
5152 Self::default()
5153 }
5154
5155 unsafe fn decode(
5156 &mut self,
5157 decoder: &mut fidl::encoding::Decoder<'_, D>,
5158 offset: usize,
5159 mut depth: fidl::encoding::Depth,
5160 ) -> fidl::Result<()> {
5161 decoder.debug_check_bounds::<Self>(offset);
5162 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5163 None => return Err(fidl::Error::NotNullable),
5164 Some(len) => len,
5165 };
5166 if len == 0 {
5168 return Ok(());
5169 };
5170 depth.increment()?;
5171 let envelope_size = 8;
5172 let bytes_len = len * envelope_size;
5173 let offset = decoder.out_of_line_offset(bytes_len)?;
5174 let mut _next_ordinal_to_read = 0;
5176 let mut next_offset = offset;
5177 let end_offset = offset + bytes_len;
5178 _next_ordinal_to_read += 1;
5179 if next_offset >= end_offset {
5180 return Ok(());
5181 }
5182
5183 while _next_ordinal_to_read < 1 {
5185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5186 _next_ordinal_to_read += 1;
5187 next_offset += envelope_size;
5188 }
5189
5190 let next_out_of_line = decoder.next_out_of_line();
5191 let handles_before = decoder.remaining_handles();
5192 if let Some((inlined, num_bytes, num_handles)) =
5193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5194 {
5195 let member_inline_size = <fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5196 if inlined != (member_inline_size <= 4) {
5197 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5198 }
5199 let inner_offset;
5200 let mut inner_depth = depth.clone();
5201 if inlined {
5202 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5203 inner_offset = next_offset;
5204 } else {
5205 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5206 inner_depth.increment()?;
5207 }
5208 let val_ref = self.format_costs.get_or_insert_with(|| {
5209 fidl::new_empty!(fidl::encoding::UnboundedVector<FormatCostEntry>, D)
5210 });
5211 fidl::decode!(
5212 fidl::encoding::UnboundedVector<FormatCostEntry>,
5213 D,
5214 val_ref,
5215 decoder,
5216 inner_offset,
5217 inner_depth
5218 )?;
5219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5220 {
5221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5222 }
5223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5225 }
5226 }
5227
5228 next_offset += envelope_size;
5229
5230 while next_offset < end_offset {
5232 _next_ordinal_to_read += 1;
5233 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5234 next_offset += envelope_size;
5235 }
5236
5237 Ok(())
5238 }
5239 }
5240
5241 impl DynamicSecureHeap {
5242 #[inline(always)]
5243 fn max_ordinal_present(&self) -> u64 {
5244 if let Some(_) = self.heap {
5245 return 1;
5246 }
5247 0
5248 }
5249 }
5250
5251 impl fidl::encoding::ValueTypeMarker for DynamicSecureHeap {
5252 type Borrowed<'a> = &'a Self;
5253 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5254 value
5255 }
5256 }
5257
5258 unsafe impl fidl::encoding::TypeMarker for DynamicSecureHeap {
5259 type Owned = Self;
5260
5261 #[inline(always)]
5262 fn inline_align(_context: fidl::encoding::Context) -> usize {
5263 8
5264 }
5265
5266 #[inline(always)]
5267 fn inline_size(_context: fidl::encoding::Context) -> usize {
5268 16
5269 }
5270 }
5271
5272 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicSecureHeap, D>
5273 for &DynamicSecureHeap
5274 {
5275 unsafe fn encode(
5276 self,
5277 encoder: &mut fidl::encoding::Encoder<'_, D>,
5278 offset: usize,
5279 mut depth: fidl::encoding::Depth,
5280 ) -> fidl::Result<()> {
5281 encoder.debug_check_bounds::<DynamicSecureHeap>(offset);
5282 let max_ordinal: u64 = self.max_ordinal_present();
5284 encoder.write_num(max_ordinal, offset);
5285 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5286 if max_ordinal == 0 {
5288 return Ok(());
5289 }
5290 depth.increment()?;
5291 let envelope_size = 8;
5292 let bytes_len = max_ordinal as usize * envelope_size;
5293 #[allow(unused_variables)]
5294 let offset = encoder.out_of_line_offset(bytes_len);
5295 let mut _prev_end_offset: usize = 0;
5296 if 1 > max_ordinal {
5297 return Ok(());
5298 }
5299
5300 let cur_offset: usize = (1 - 1) * envelope_size;
5303
5304 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5306
5307 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
5312 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
5313 encoder,
5314 offset + cur_offset,
5315 depth,
5316 )?;
5317
5318 _prev_end_offset = cur_offset + envelope_size;
5319
5320 Ok(())
5321 }
5322 }
5323
5324 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicSecureHeap {
5325 #[inline(always)]
5326 fn new_empty() -> Self {
5327 Self::default()
5328 }
5329
5330 unsafe fn decode(
5331 &mut self,
5332 decoder: &mut fidl::encoding::Decoder<'_, D>,
5333 offset: usize,
5334 mut depth: fidl::encoding::Depth,
5335 ) -> fidl::Result<()> {
5336 decoder.debug_check_bounds::<Self>(offset);
5337 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5338 None => return Err(fidl::Error::NotNullable),
5339 Some(len) => len,
5340 };
5341 if len == 0 {
5343 return Ok(());
5344 };
5345 depth.increment()?;
5346 let envelope_size = 8;
5347 let bytes_len = len * envelope_size;
5348 let offset = decoder.out_of_line_offset(bytes_len)?;
5349 let mut _next_ordinal_to_read = 0;
5351 let mut next_offset = offset;
5352 let end_offset = offset + bytes_len;
5353 _next_ordinal_to_read += 1;
5354 if next_offset >= end_offset {
5355 return Ok(());
5356 }
5357
5358 while _next_ordinal_to_read < 1 {
5360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5361 _next_ordinal_to_read += 1;
5362 next_offset += envelope_size;
5363 }
5364
5365 let next_out_of_line = decoder.next_out_of_line();
5366 let handles_before = decoder.remaining_handles();
5367 if let Some((inlined, num_bytes, num_handles)) =
5368 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5369 {
5370 let member_inline_size =
5371 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5372 if inlined != (member_inline_size <= 4) {
5373 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5374 }
5375 let inner_offset;
5376 let mut inner_depth = depth.clone();
5377 if inlined {
5378 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5379 inner_offset = next_offset;
5380 } else {
5381 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5382 inner_depth.increment()?;
5383 }
5384 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
5385 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
5386 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5387 {
5388 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5389 }
5390 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5391 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5392 }
5393 }
5394
5395 next_offset += envelope_size;
5396
5397 while next_offset < end_offset {
5399 _next_ordinal_to_read += 1;
5400 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5401 next_offset += envelope_size;
5402 }
5403
5404 Ok(())
5405 }
5406 }
5407
5408 impl FormatCostEntry {
5409 #[inline(always)]
5410 fn max_ordinal_present(&self) -> u64 {
5411 if let Some(_) = self.cost {
5412 return 2;
5413 }
5414 if let Some(_) = self.key {
5415 return 1;
5416 }
5417 0
5418 }
5419 }
5420
5421 impl fidl::encoding::ValueTypeMarker for FormatCostEntry {
5422 type Borrowed<'a> = &'a Self;
5423 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5424 value
5425 }
5426 }
5427
5428 unsafe impl fidl::encoding::TypeMarker for FormatCostEntry {
5429 type Owned = Self;
5430
5431 #[inline(always)]
5432 fn inline_align(_context: fidl::encoding::Context) -> usize {
5433 8
5434 }
5435
5436 #[inline(always)]
5437 fn inline_size(_context: fidl::encoding::Context) -> usize {
5438 16
5439 }
5440 }
5441
5442 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCostEntry, D>
5443 for &FormatCostEntry
5444 {
5445 unsafe fn encode(
5446 self,
5447 encoder: &mut fidl::encoding::Encoder<'_, D>,
5448 offset: usize,
5449 mut depth: fidl::encoding::Depth,
5450 ) -> fidl::Result<()> {
5451 encoder.debug_check_bounds::<FormatCostEntry>(offset);
5452 let max_ordinal: u64 = self.max_ordinal_present();
5454 encoder.write_num(max_ordinal, offset);
5455 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5456 if max_ordinal == 0 {
5458 return Ok(());
5459 }
5460 depth.increment()?;
5461 let envelope_size = 8;
5462 let bytes_len = max_ordinal as usize * envelope_size;
5463 #[allow(unused_variables)]
5464 let offset = encoder.out_of_line_offset(bytes_len);
5465 let mut _prev_end_offset: usize = 0;
5466 if 1 > max_ordinal {
5467 return Ok(());
5468 }
5469
5470 let cur_offset: usize = (1 - 1) * envelope_size;
5473
5474 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5476
5477 fidl::encoding::encode_in_envelope_optional::<FormatCostKey, D>(
5482 self.key.as_ref().map(<FormatCostKey as fidl::encoding::ValueTypeMarker>::borrow),
5483 encoder,
5484 offset + cur_offset,
5485 depth,
5486 )?;
5487
5488 _prev_end_offset = cur_offset + envelope_size;
5489 if 2 > max_ordinal {
5490 return Ok(());
5491 }
5492
5493 let cur_offset: usize = (2 - 1) * envelope_size;
5496
5497 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5499
5500 fidl::encoding::encode_in_envelope_optional::<f32, D>(
5505 self.cost.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
5506 encoder,
5507 offset + cur_offset,
5508 depth,
5509 )?;
5510
5511 _prev_end_offset = cur_offset + envelope_size;
5512
5513 Ok(())
5514 }
5515 }
5516
5517 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCostEntry {
5518 #[inline(always)]
5519 fn new_empty() -> Self {
5520 Self::default()
5521 }
5522
5523 unsafe fn decode(
5524 &mut self,
5525 decoder: &mut fidl::encoding::Decoder<'_, D>,
5526 offset: usize,
5527 mut depth: fidl::encoding::Depth,
5528 ) -> fidl::Result<()> {
5529 decoder.debug_check_bounds::<Self>(offset);
5530 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5531 None => return Err(fidl::Error::NotNullable),
5532 Some(len) => len,
5533 };
5534 if len == 0 {
5536 return Ok(());
5537 };
5538 depth.increment()?;
5539 let envelope_size = 8;
5540 let bytes_len = len * envelope_size;
5541 let offset = decoder.out_of_line_offset(bytes_len)?;
5542 let mut _next_ordinal_to_read = 0;
5544 let mut next_offset = offset;
5545 let end_offset = offset + bytes_len;
5546 _next_ordinal_to_read += 1;
5547 if next_offset >= end_offset {
5548 return Ok(());
5549 }
5550
5551 while _next_ordinal_to_read < 1 {
5553 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5554 _next_ordinal_to_read += 1;
5555 next_offset += envelope_size;
5556 }
5557
5558 let next_out_of_line = decoder.next_out_of_line();
5559 let handles_before = decoder.remaining_handles();
5560 if let Some((inlined, num_bytes, num_handles)) =
5561 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5562 {
5563 let member_inline_size =
5564 <FormatCostKey as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5565 if inlined != (member_inline_size <= 4) {
5566 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5567 }
5568 let inner_offset;
5569 let mut inner_depth = depth.clone();
5570 if inlined {
5571 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5572 inner_offset = next_offset;
5573 } else {
5574 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5575 inner_depth.increment()?;
5576 }
5577 let val_ref = self.key.get_or_insert_with(|| fidl::new_empty!(FormatCostKey, D));
5578 fidl::decode!(FormatCostKey, D, val_ref, decoder, inner_offset, inner_depth)?;
5579 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5580 {
5581 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5582 }
5583 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5584 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5585 }
5586 }
5587
5588 next_offset += envelope_size;
5589 _next_ordinal_to_read += 1;
5590 if next_offset >= end_offset {
5591 return Ok(());
5592 }
5593
5594 while _next_ordinal_to_read < 2 {
5596 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5597 _next_ordinal_to_read += 1;
5598 next_offset += envelope_size;
5599 }
5600
5601 let next_out_of_line = decoder.next_out_of_line();
5602 let handles_before = decoder.remaining_handles();
5603 if let Some((inlined, num_bytes, num_handles)) =
5604 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5605 {
5606 let member_inline_size =
5607 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5608 if inlined != (member_inline_size <= 4) {
5609 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5610 }
5611 let inner_offset;
5612 let mut inner_depth = depth.clone();
5613 if inlined {
5614 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5615 inner_offset = next_offset;
5616 } else {
5617 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5618 inner_depth.increment()?;
5619 }
5620 let val_ref = self.cost.get_or_insert_with(|| fidl::new_empty!(f32, D));
5621 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
5622 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5623 {
5624 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5625 }
5626 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5627 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5628 }
5629 }
5630
5631 next_offset += envelope_size;
5632
5633 while next_offset < end_offset {
5635 _next_ordinal_to_read += 1;
5636 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5637 next_offset += envelope_size;
5638 }
5639
5640 Ok(())
5641 }
5642 }
5643
5644 impl FormatCostKey {
5645 #[inline(always)]
5646 fn max_ordinal_present(&self) -> u64 {
5647 if let Some(_) = self.buffer_usage_bits {
5648 return 3;
5649 }
5650 if let Some(_) = self.pixel_format_modifier {
5651 return 2;
5652 }
5653 if let Some(_) = self.pixel_format {
5654 return 1;
5655 }
5656 0
5657 }
5658 }
5659
5660 impl fidl::encoding::ValueTypeMarker for FormatCostKey {
5661 type Borrowed<'a> = &'a Self;
5662 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5663 value
5664 }
5665 }
5666
5667 unsafe impl fidl::encoding::TypeMarker for FormatCostKey {
5668 type Owned = Self;
5669
5670 #[inline(always)]
5671 fn inline_align(_context: fidl::encoding::Context) -> usize {
5672 8
5673 }
5674
5675 #[inline(always)]
5676 fn inline_size(_context: fidl::encoding::Context) -> usize {
5677 16
5678 }
5679 }
5680
5681 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCostKey, D>
5682 for &FormatCostKey
5683 {
5684 unsafe fn encode(
5685 self,
5686 encoder: &mut fidl::encoding::Encoder<'_, D>,
5687 offset: usize,
5688 mut depth: fidl::encoding::Depth,
5689 ) -> fidl::Result<()> {
5690 encoder.debug_check_bounds::<FormatCostKey>(offset);
5691 let max_ordinal: u64 = self.max_ordinal_present();
5693 encoder.write_num(max_ordinal, offset);
5694 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5695 if max_ordinal == 0 {
5697 return Ok(());
5698 }
5699 depth.increment()?;
5700 let envelope_size = 8;
5701 let bytes_len = max_ordinal as usize * envelope_size;
5702 #[allow(unused_variables)]
5703 let offset = encoder.out_of_line_offset(bytes_len);
5704 let mut _prev_end_offset: usize = 0;
5705 if 1 > max_ordinal {
5706 return Ok(());
5707 }
5708
5709 let cur_offset: usize = (1 - 1) * envelope_size;
5712
5713 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5715
5716 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormat, D>(
5721 self.pixel_format.as_ref().map(<fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow),
5722 encoder, offset + cur_offset, depth
5723 )?;
5724
5725 _prev_end_offset = cur_offset + envelope_size;
5726 if 2 > max_ordinal {
5727 return Ok(());
5728 }
5729
5730 let cur_offset: usize = (2 - 1) * envelope_size;
5733
5734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5736
5737 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormatModifier, D>(
5742 self.pixel_format_modifier.as_ref().map(<fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow),
5743 encoder, offset + cur_offset, depth
5744 )?;
5745
5746 _prev_end_offset = cur_offset + envelope_size;
5747 if 3 > max_ordinal {
5748 return Ok(());
5749 }
5750
5751 let cur_offset: usize = (3 - 1) * envelope_size;
5754
5755 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5757
5758 fidl::encoding::encode_in_envelope_optional::<BufferUsage, D>(
5763 self.buffer_usage_bits
5764 .as_ref()
5765 .map(<BufferUsage as fidl::encoding::ValueTypeMarker>::borrow),
5766 encoder,
5767 offset + cur_offset,
5768 depth,
5769 )?;
5770
5771 _prev_end_offset = cur_offset + envelope_size;
5772
5773 Ok(())
5774 }
5775 }
5776
5777 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCostKey {
5778 #[inline(always)]
5779 fn new_empty() -> Self {
5780 Self::default()
5781 }
5782
5783 unsafe fn decode(
5784 &mut self,
5785 decoder: &mut fidl::encoding::Decoder<'_, D>,
5786 offset: usize,
5787 mut depth: fidl::encoding::Depth,
5788 ) -> fidl::Result<()> {
5789 decoder.debug_check_bounds::<Self>(offset);
5790 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5791 None => return Err(fidl::Error::NotNullable),
5792 Some(len) => len,
5793 };
5794 if len == 0 {
5796 return Ok(());
5797 };
5798 depth.increment()?;
5799 let envelope_size = 8;
5800 let bytes_len = len * envelope_size;
5801 let offset = decoder.out_of_line_offset(bytes_len)?;
5802 let mut _next_ordinal_to_read = 0;
5804 let mut next_offset = offset;
5805 let end_offset = offset + bytes_len;
5806 _next_ordinal_to_read += 1;
5807 if next_offset >= end_offset {
5808 return Ok(());
5809 }
5810
5811 while _next_ordinal_to_read < 1 {
5813 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5814 _next_ordinal_to_read += 1;
5815 next_offset += envelope_size;
5816 }
5817
5818 let next_out_of_line = decoder.next_out_of_line();
5819 let handles_before = decoder.remaining_handles();
5820 if let Some((inlined, num_bytes, num_handles)) =
5821 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5822 {
5823 let member_inline_size = <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5824 if inlined != (member_inline_size <= 4) {
5825 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5826 }
5827 let inner_offset;
5828 let mut inner_depth = depth.clone();
5829 if inlined {
5830 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5831 inner_offset = next_offset;
5832 } else {
5833 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5834 inner_depth.increment()?;
5835 }
5836 let val_ref = self.pixel_format.get_or_insert_with(|| {
5837 fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D)
5838 });
5839 fidl::decode!(
5840 fidl_fuchsia_images2__common::PixelFormat,
5841 D,
5842 val_ref,
5843 decoder,
5844 inner_offset,
5845 inner_depth
5846 )?;
5847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5848 {
5849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5850 }
5851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5853 }
5854 }
5855
5856 next_offset += envelope_size;
5857 _next_ordinal_to_read += 1;
5858 if next_offset >= end_offset {
5859 return Ok(());
5860 }
5861
5862 while _next_ordinal_to_read < 2 {
5864 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5865 _next_ordinal_to_read += 1;
5866 next_offset += envelope_size;
5867 }
5868
5869 let next_out_of_line = decoder.next_out_of_line();
5870 let handles_before = decoder.remaining_handles();
5871 if let Some((inlined, num_bytes, num_handles)) =
5872 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5873 {
5874 let member_inline_size = <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5875 if inlined != (member_inline_size <= 4) {
5876 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5877 }
5878 let inner_offset;
5879 let mut inner_depth = depth.clone();
5880 if inlined {
5881 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5882 inner_offset = next_offset;
5883 } else {
5884 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5885 inner_depth.increment()?;
5886 }
5887 let val_ref = self.pixel_format_modifier.get_or_insert_with(|| {
5888 fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormatModifier, D)
5889 });
5890 fidl::decode!(
5891 fidl_fuchsia_images2__common::PixelFormatModifier,
5892 D,
5893 val_ref,
5894 decoder,
5895 inner_offset,
5896 inner_depth
5897 )?;
5898 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5899 {
5900 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5901 }
5902 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5903 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5904 }
5905 }
5906
5907 next_offset += envelope_size;
5908 _next_ordinal_to_read += 1;
5909 if next_offset >= end_offset {
5910 return Ok(());
5911 }
5912
5913 while _next_ordinal_to_read < 3 {
5915 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5916 _next_ordinal_to_read += 1;
5917 next_offset += envelope_size;
5918 }
5919
5920 let next_out_of_line = decoder.next_out_of_line();
5921 let handles_before = decoder.remaining_handles();
5922 if let Some((inlined, num_bytes, num_handles)) =
5923 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5924 {
5925 let member_inline_size =
5926 <BufferUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5927 if inlined != (member_inline_size <= 4) {
5928 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5929 }
5930 let inner_offset;
5931 let mut inner_depth = depth.clone();
5932 if inlined {
5933 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5934 inner_offset = next_offset;
5935 } else {
5936 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5937 inner_depth.increment()?;
5938 }
5939 let val_ref =
5940 self.buffer_usage_bits.get_or_insert_with(|| fidl::new_empty!(BufferUsage, D));
5941 fidl::decode!(BufferUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
5942 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5943 {
5944 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5945 }
5946 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5947 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5948 }
5949 }
5950
5951 next_offset += envelope_size;
5952
5953 while next_offset < end_offset {
5955 _next_ordinal_to_read += 1;
5956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5957 next_offset += envelope_size;
5958 }
5959
5960 Ok(())
5961 }
5962 }
5963
5964 impl FormatCosts {
5965 #[inline(always)]
5966 fn max_ordinal_present(&self) -> u64 {
5967 if let Some(_) = self.format_costs {
5968 return 1;
5969 }
5970 0
5971 }
5972 }
5973
5974 impl fidl::encoding::ValueTypeMarker for FormatCosts {
5975 type Borrowed<'a> = &'a Self;
5976 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5977 value
5978 }
5979 }
5980
5981 unsafe impl fidl::encoding::TypeMarker for FormatCosts {
5982 type Owned = Self;
5983
5984 #[inline(always)]
5985 fn inline_align(_context: fidl::encoding::Context) -> usize {
5986 8
5987 }
5988
5989 #[inline(always)]
5990 fn inline_size(_context: fidl::encoding::Context) -> usize {
5991 16
5992 }
5993 }
5994
5995 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCosts, D>
5996 for &FormatCosts
5997 {
5998 unsafe fn encode(
5999 self,
6000 encoder: &mut fidl::encoding::Encoder<'_, D>,
6001 offset: usize,
6002 mut depth: fidl::encoding::Depth,
6003 ) -> fidl::Result<()> {
6004 encoder.debug_check_bounds::<FormatCosts>(offset);
6005 let max_ordinal: u64 = self.max_ordinal_present();
6007 encoder.write_num(max_ordinal, offset);
6008 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6009 if max_ordinal == 0 {
6011 return Ok(());
6012 }
6013 depth.increment()?;
6014 let envelope_size = 8;
6015 let bytes_len = max_ordinal as usize * envelope_size;
6016 #[allow(unused_variables)]
6017 let offset = encoder.out_of_line_offset(bytes_len);
6018 let mut _prev_end_offset: usize = 0;
6019 if 1 > max_ordinal {
6020 return Ok(());
6021 }
6022
6023 let cur_offset: usize = (1 - 1) * envelope_size;
6026
6027 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6029
6030 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<FormatCostEntry>, D>(
6035 self.format_costs.as_ref().map(<fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::ValueTypeMarker>::borrow),
6036 encoder, offset + cur_offset, depth
6037 )?;
6038
6039 _prev_end_offset = cur_offset + envelope_size;
6040
6041 Ok(())
6042 }
6043 }
6044
6045 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCosts {
6046 #[inline(always)]
6047 fn new_empty() -> Self {
6048 Self::default()
6049 }
6050
6051 unsafe fn decode(
6052 &mut self,
6053 decoder: &mut fidl::encoding::Decoder<'_, D>,
6054 offset: usize,
6055 mut depth: fidl::encoding::Depth,
6056 ) -> fidl::Result<()> {
6057 decoder.debug_check_bounds::<Self>(offset);
6058 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6059 None => return Err(fidl::Error::NotNullable),
6060 Some(len) => len,
6061 };
6062 if len == 0 {
6064 return Ok(());
6065 };
6066 depth.increment()?;
6067 let envelope_size = 8;
6068 let bytes_len = len * envelope_size;
6069 let offset = decoder.out_of_line_offset(bytes_len)?;
6070 let mut _next_ordinal_to_read = 0;
6072 let mut next_offset = offset;
6073 let end_offset = offset + bytes_len;
6074 _next_ordinal_to_read += 1;
6075 if next_offset >= end_offset {
6076 return Ok(());
6077 }
6078
6079 while _next_ordinal_to_read < 1 {
6081 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6082 _next_ordinal_to_read += 1;
6083 next_offset += envelope_size;
6084 }
6085
6086 let next_out_of_line = decoder.next_out_of_line();
6087 let handles_before = decoder.remaining_handles();
6088 if let Some((inlined, num_bytes, num_handles)) =
6089 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6090 {
6091 let member_inline_size = <fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6092 if inlined != (member_inline_size <= 4) {
6093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6094 }
6095 let inner_offset;
6096 let mut inner_depth = depth.clone();
6097 if inlined {
6098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6099 inner_offset = next_offset;
6100 } else {
6101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6102 inner_depth.increment()?;
6103 }
6104 let val_ref = self.format_costs.get_or_insert_with(|| {
6105 fidl::new_empty!(fidl::encoding::UnboundedVector<FormatCostEntry>, D)
6106 });
6107 fidl::decode!(
6108 fidl::encoding::UnboundedVector<FormatCostEntry>,
6109 D,
6110 val_ref,
6111 decoder,
6112 inner_offset,
6113 inner_depth
6114 )?;
6115 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6116 {
6117 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6118 }
6119 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6120 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6121 }
6122 }
6123
6124 next_offset += envelope_size;
6125
6126 while next_offset < end_offset {
6128 _next_ordinal_to_read += 1;
6129 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6130 next_offset += envelope_size;
6131 }
6132
6133 Ok(())
6134 }
6135 }
6136
6137 impl Heap {
6138 #[inline(always)]
6139 fn max_ordinal_present(&self) -> u64 {
6140 if let Some(_) = self.id {
6141 return 2;
6142 }
6143 if let Some(_) = self.heap_type {
6144 return 1;
6145 }
6146 0
6147 }
6148 }
6149
6150 impl fidl::encoding::ValueTypeMarker for Heap {
6151 type Borrowed<'a> = &'a Self;
6152 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6153 value
6154 }
6155 }
6156
6157 unsafe impl fidl::encoding::TypeMarker for Heap {
6158 type Owned = Self;
6159
6160 #[inline(always)]
6161 fn inline_align(_context: fidl::encoding::Context) -> usize {
6162 8
6163 }
6164
6165 #[inline(always)]
6166 fn inline_size(_context: fidl::encoding::Context) -> usize {
6167 16
6168 }
6169 }
6170
6171 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Heap, D> for &Heap {
6172 unsafe fn encode(
6173 self,
6174 encoder: &mut fidl::encoding::Encoder<'_, D>,
6175 offset: usize,
6176 mut depth: fidl::encoding::Depth,
6177 ) -> fidl::Result<()> {
6178 encoder.debug_check_bounds::<Heap>(offset);
6179 let max_ordinal: u64 = self.max_ordinal_present();
6181 encoder.write_num(max_ordinal, offset);
6182 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6183 if max_ordinal == 0 {
6185 return Ok(());
6186 }
6187 depth.increment()?;
6188 let envelope_size = 8;
6189 let bytes_len = max_ordinal as usize * envelope_size;
6190 #[allow(unused_variables)]
6191 let offset = encoder.out_of_line_offset(bytes_len);
6192 let mut _prev_end_offset: usize = 0;
6193 if 1 > max_ordinal {
6194 return Ok(());
6195 }
6196
6197 let cur_offset: usize = (1 - 1) * envelope_size;
6200
6201 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6203
6204 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
6209 self.heap_type.as_ref().map(
6210 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
6211 ),
6212 encoder,
6213 offset + cur_offset,
6214 depth,
6215 )?;
6216
6217 _prev_end_offset = cur_offset + envelope_size;
6218 if 2 > max_ordinal {
6219 return Ok(());
6220 }
6221
6222 let cur_offset: usize = (2 - 1) * envelope_size;
6225
6226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6228
6229 fidl::encoding::encode_in_envelope_optional::<u64, D>(
6234 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
6235 encoder,
6236 offset + cur_offset,
6237 depth,
6238 )?;
6239
6240 _prev_end_offset = cur_offset + envelope_size;
6241
6242 Ok(())
6243 }
6244 }
6245
6246 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Heap {
6247 #[inline(always)]
6248 fn new_empty() -> Self {
6249 Self::default()
6250 }
6251
6252 unsafe fn decode(
6253 &mut self,
6254 decoder: &mut fidl::encoding::Decoder<'_, D>,
6255 offset: usize,
6256 mut depth: fidl::encoding::Depth,
6257 ) -> fidl::Result<()> {
6258 decoder.debug_check_bounds::<Self>(offset);
6259 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6260 None => return Err(fidl::Error::NotNullable),
6261 Some(len) => len,
6262 };
6263 if len == 0 {
6265 return Ok(());
6266 };
6267 depth.increment()?;
6268 let envelope_size = 8;
6269 let bytes_len = len * envelope_size;
6270 let offset = decoder.out_of_line_offset(bytes_len)?;
6271 let mut _next_ordinal_to_read = 0;
6273 let mut next_offset = offset;
6274 let end_offset = offset + bytes_len;
6275 _next_ordinal_to_read += 1;
6276 if next_offset >= end_offset {
6277 return Ok(());
6278 }
6279
6280 while _next_ordinal_to_read < 1 {
6282 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6283 _next_ordinal_to_read += 1;
6284 next_offset += envelope_size;
6285 }
6286
6287 let next_out_of_line = decoder.next_out_of_line();
6288 let handles_before = decoder.remaining_handles();
6289 if let Some((inlined, num_bytes, num_handles)) =
6290 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6291 {
6292 let member_inline_size =
6293 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
6294 decoder.context,
6295 );
6296 if inlined != (member_inline_size <= 4) {
6297 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6298 }
6299 let inner_offset;
6300 let mut inner_depth = depth.clone();
6301 if inlined {
6302 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6303 inner_offset = next_offset;
6304 } else {
6305 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6306 inner_depth.increment()?;
6307 }
6308 let val_ref = self
6309 .heap_type
6310 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
6311 fidl::decode!(
6312 fidl::encoding::BoundedString<128>,
6313 D,
6314 val_ref,
6315 decoder,
6316 inner_offset,
6317 inner_depth
6318 )?;
6319 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6320 {
6321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6322 }
6323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6325 }
6326 }
6327
6328 next_offset += envelope_size;
6329 _next_ordinal_to_read += 1;
6330 if next_offset >= end_offset {
6331 return Ok(());
6332 }
6333
6334 while _next_ordinal_to_read < 2 {
6336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6337 _next_ordinal_to_read += 1;
6338 next_offset += envelope_size;
6339 }
6340
6341 let next_out_of_line = decoder.next_out_of_line();
6342 let handles_before = decoder.remaining_handles();
6343 if let Some((inlined, num_bytes, num_handles)) =
6344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6345 {
6346 let member_inline_size =
6347 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6348 if inlined != (member_inline_size <= 4) {
6349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6350 }
6351 let inner_offset;
6352 let mut inner_depth = depth.clone();
6353 if inlined {
6354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6355 inner_offset = next_offset;
6356 } else {
6357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6358 inner_depth.increment()?;
6359 }
6360 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
6361 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6362 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6363 {
6364 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6365 }
6366 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6367 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6368 }
6369 }
6370
6371 next_offset += envelope_size;
6372
6373 while next_offset < end_offset {
6375 _next_ordinal_to_read += 1;
6376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6377 next_offset += envelope_size;
6378 }
6379
6380 Ok(())
6381 }
6382 }
6383
6384 impl ImageFormatConstraints {
6385 #[inline(always)]
6386 fn max_ordinal_present(&self) -> u64 {
6387 if let Some(_) = self.is_alpha_present {
6388 return 17;
6389 }
6390 if let Some(_) = self.require_bytes_per_row_at_pixel_boundary {
6391 return 16;
6392 }
6393 if let Some(_) = self.pixel_format_and_modifiers {
6394 return 15;
6395 }
6396 if let Some(_) = self.start_offset_divisor {
6397 return 14;
6398 }
6399 if let Some(_) = self.bytes_per_row_divisor {
6400 return 13;
6401 }
6402 if let Some(_) = self.required_max_size {
6403 return 12;
6404 }
6405 if let Some(_) = self.required_min_size {
6406 return 11;
6407 }
6408 if let Some(_) = self.display_rect_alignment {
6409 return 10;
6410 }
6411 if let Some(_) = self.size_alignment {
6412 return 9;
6413 }
6414 if let Some(_) = self.max_width_times_height {
6415 return 8;
6416 }
6417 if let Some(_) = self.max_bytes_per_row {
6418 return 7;
6419 }
6420 if let Some(_) = self.min_bytes_per_row {
6421 return 6;
6422 }
6423 if let Some(_) = self.max_size {
6424 return 5;
6425 }
6426 if let Some(_) = self.min_size {
6427 return 4;
6428 }
6429 if let Some(_) = self.color_spaces {
6430 return 3;
6431 }
6432 if let Some(_) = self.pixel_format_modifier {
6433 return 2;
6434 }
6435 if let Some(_) = self.pixel_format {
6436 return 1;
6437 }
6438 0
6439 }
6440 }
6441
6442 impl fidl::encoding::ValueTypeMarker for ImageFormatConstraints {
6443 type Borrowed<'a> = &'a Self;
6444 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6445 value
6446 }
6447 }
6448
6449 unsafe impl fidl::encoding::TypeMarker for ImageFormatConstraints {
6450 type Owned = Self;
6451
6452 #[inline(always)]
6453 fn inline_align(_context: fidl::encoding::Context) -> usize {
6454 8
6455 }
6456
6457 #[inline(always)]
6458 fn inline_size(_context: fidl::encoding::Context) -> usize {
6459 16
6460 }
6461 }
6462
6463 unsafe impl<D: fidl::encoding::ResourceDialect>
6464 fidl::encoding::Encode<ImageFormatConstraints, D> for &ImageFormatConstraints
6465 {
6466 unsafe fn encode(
6467 self,
6468 encoder: &mut fidl::encoding::Encoder<'_, D>,
6469 offset: usize,
6470 mut depth: fidl::encoding::Depth,
6471 ) -> fidl::Result<()> {
6472 encoder.debug_check_bounds::<ImageFormatConstraints>(offset);
6473 let max_ordinal: u64 = self.max_ordinal_present();
6475 encoder.write_num(max_ordinal, offset);
6476 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6477 if max_ordinal == 0 {
6479 return Ok(());
6480 }
6481 depth.increment()?;
6482 let envelope_size = 8;
6483 let bytes_len = max_ordinal as usize * envelope_size;
6484 #[allow(unused_variables)]
6485 let offset = encoder.out_of_line_offset(bytes_len);
6486 let mut _prev_end_offset: usize = 0;
6487 if 1 > max_ordinal {
6488 return Ok(());
6489 }
6490
6491 let cur_offset: usize = (1 - 1) * envelope_size;
6494
6495 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6497
6498 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormat, D>(
6503 self.pixel_format.as_ref().map(<fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow),
6504 encoder, offset + cur_offset, depth
6505 )?;
6506
6507 _prev_end_offset = cur_offset + envelope_size;
6508 if 2 > max_ordinal {
6509 return Ok(());
6510 }
6511
6512 let cur_offset: usize = (2 - 1) * envelope_size;
6515
6516 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6518
6519 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormatModifier, D>(
6524 self.pixel_format_modifier.as_ref().map(<fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow),
6525 encoder, offset + cur_offset, depth
6526 )?;
6527
6528 _prev_end_offset = cur_offset + envelope_size;
6529 if 3 > max_ordinal {
6530 return Ok(());
6531 }
6532
6533 let cur_offset: usize = (3 - 1) * envelope_size;
6536
6537 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6539
6540 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D>(
6545 self.color_spaces.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6546 encoder, offset + cur_offset, depth
6547 )?;
6548
6549 _prev_end_offset = cur_offset + envelope_size;
6550 if 4 > max_ordinal {
6551 return Ok(());
6552 }
6553
6554 let cur_offset: usize = (4 - 1) * envelope_size;
6557
6558 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6560
6561 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6566 self.min_size.as_ref().map(
6567 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6568 ),
6569 encoder,
6570 offset + cur_offset,
6571 depth,
6572 )?;
6573
6574 _prev_end_offset = cur_offset + envelope_size;
6575 if 5 > max_ordinal {
6576 return Ok(());
6577 }
6578
6579 let cur_offset: usize = (5 - 1) * envelope_size;
6582
6583 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6585
6586 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6591 self.max_size.as_ref().map(
6592 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6593 ),
6594 encoder,
6595 offset + cur_offset,
6596 depth,
6597 )?;
6598
6599 _prev_end_offset = cur_offset + envelope_size;
6600 if 6 > max_ordinal {
6601 return Ok(());
6602 }
6603
6604 let cur_offset: usize = (6 - 1) * envelope_size;
6607
6608 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6610
6611 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6616 self.min_bytes_per_row
6617 .as_ref()
6618 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6619 encoder,
6620 offset + cur_offset,
6621 depth,
6622 )?;
6623
6624 _prev_end_offset = cur_offset + envelope_size;
6625 if 7 > max_ordinal {
6626 return Ok(());
6627 }
6628
6629 let cur_offset: usize = (7 - 1) * envelope_size;
6632
6633 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6635
6636 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6641 self.max_bytes_per_row
6642 .as_ref()
6643 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6644 encoder,
6645 offset + cur_offset,
6646 depth,
6647 )?;
6648
6649 _prev_end_offset = cur_offset + envelope_size;
6650 if 8 > max_ordinal {
6651 return Ok(());
6652 }
6653
6654 let cur_offset: usize = (8 - 1) * envelope_size;
6657
6658 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6660
6661 fidl::encoding::encode_in_envelope_optional::<u64, D>(
6666 self.max_width_times_height
6667 .as_ref()
6668 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
6669 encoder,
6670 offset + cur_offset,
6671 depth,
6672 )?;
6673
6674 _prev_end_offset = cur_offset + envelope_size;
6675 if 9 > max_ordinal {
6676 return Ok(());
6677 }
6678
6679 let cur_offset: usize = (9 - 1) * envelope_size;
6682
6683 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6685
6686 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6691 self.size_alignment.as_ref().map(
6692 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6693 ),
6694 encoder,
6695 offset + cur_offset,
6696 depth,
6697 )?;
6698
6699 _prev_end_offset = cur_offset + envelope_size;
6700 if 10 > max_ordinal {
6701 return Ok(());
6702 }
6703
6704 let cur_offset: usize = (10 - 1) * envelope_size;
6707
6708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6710
6711 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6716 self.display_rect_alignment.as_ref().map(
6717 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6718 ),
6719 encoder,
6720 offset + cur_offset,
6721 depth,
6722 )?;
6723
6724 _prev_end_offset = cur_offset + envelope_size;
6725 if 11 > max_ordinal {
6726 return Ok(());
6727 }
6728
6729 let cur_offset: usize = (11 - 1) * envelope_size;
6732
6733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6735
6736 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6741 self.required_min_size.as_ref().map(
6742 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6743 ),
6744 encoder,
6745 offset + cur_offset,
6746 depth,
6747 )?;
6748
6749 _prev_end_offset = cur_offset + envelope_size;
6750 if 12 > max_ordinal {
6751 return Ok(());
6752 }
6753
6754 let cur_offset: usize = (12 - 1) * envelope_size;
6757
6758 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6760
6761 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6766 self.required_max_size.as_ref().map(
6767 <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6768 ),
6769 encoder,
6770 offset + cur_offset,
6771 depth,
6772 )?;
6773
6774 _prev_end_offset = cur_offset + envelope_size;
6775 if 13 > max_ordinal {
6776 return Ok(());
6777 }
6778
6779 let cur_offset: usize = (13 - 1) * envelope_size;
6782
6783 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6785
6786 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6791 self.bytes_per_row_divisor
6792 .as_ref()
6793 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6794 encoder,
6795 offset + cur_offset,
6796 depth,
6797 )?;
6798
6799 _prev_end_offset = cur_offset + envelope_size;
6800 if 14 > max_ordinal {
6801 return Ok(());
6802 }
6803
6804 let cur_offset: usize = (14 - 1) * envelope_size;
6807
6808 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6810
6811 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6816 self.start_offset_divisor
6817 .as_ref()
6818 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6819 encoder,
6820 offset + cur_offset,
6821 depth,
6822 )?;
6823
6824 _prev_end_offset = cur_offset + envelope_size;
6825 if 15 > max_ordinal {
6826 return Ok(());
6827 }
6828
6829 let cur_offset: usize = (15 - 1) * envelope_size;
6832
6833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6835
6836 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PixelFormatAndModifier, 64>, D>(
6841 self.pixel_format_and_modifiers.as_ref().map(<fidl::encoding::Vector<PixelFormatAndModifier, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6842 encoder, offset + cur_offset, depth
6843 )?;
6844
6845 _prev_end_offset = cur_offset + envelope_size;
6846 if 16 > max_ordinal {
6847 return Ok(());
6848 }
6849
6850 let cur_offset: usize = (16 - 1) * envelope_size;
6853
6854 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6856
6857 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6862 self.require_bytes_per_row_at_pixel_boundary
6863 .as_ref()
6864 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6865 encoder,
6866 offset + cur_offset,
6867 depth,
6868 )?;
6869
6870 _prev_end_offset = cur_offset + envelope_size;
6871 if 17 > max_ordinal {
6872 return Ok(());
6873 }
6874
6875 let cur_offset: usize = (17 - 1) * envelope_size;
6878
6879 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6881
6882 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6887 self.is_alpha_present
6888 .as_ref()
6889 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6890 encoder,
6891 offset + cur_offset,
6892 depth,
6893 )?;
6894
6895 _prev_end_offset = cur_offset + envelope_size;
6896
6897 Ok(())
6898 }
6899 }
6900
6901 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6902 for ImageFormatConstraints
6903 {
6904 #[inline(always)]
6905 fn new_empty() -> Self {
6906 Self::default()
6907 }
6908
6909 unsafe fn decode(
6910 &mut self,
6911 decoder: &mut fidl::encoding::Decoder<'_, D>,
6912 offset: usize,
6913 mut depth: fidl::encoding::Depth,
6914 ) -> fidl::Result<()> {
6915 decoder.debug_check_bounds::<Self>(offset);
6916 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6917 None => return Err(fidl::Error::NotNullable),
6918 Some(len) => len,
6919 };
6920 if len == 0 {
6922 return Ok(());
6923 };
6924 depth.increment()?;
6925 let envelope_size = 8;
6926 let bytes_len = len * envelope_size;
6927 let offset = decoder.out_of_line_offset(bytes_len)?;
6928 let mut _next_ordinal_to_read = 0;
6930 let mut next_offset = offset;
6931 let end_offset = offset + bytes_len;
6932 _next_ordinal_to_read += 1;
6933 if next_offset >= end_offset {
6934 return Ok(());
6935 }
6936
6937 while _next_ordinal_to_read < 1 {
6939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6940 _next_ordinal_to_read += 1;
6941 next_offset += envelope_size;
6942 }
6943
6944 let next_out_of_line = decoder.next_out_of_line();
6945 let handles_before = decoder.remaining_handles();
6946 if let Some((inlined, num_bytes, num_handles)) =
6947 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6948 {
6949 let member_inline_size = <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6950 if inlined != (member_inline_size <= 4) {
6951 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6952 }
6953 let inner_offset;
6954 let mut inner_depth = depth.clone();
6955 if inlined {
6956 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6957 inner_offset = next_offset;
6958 } else {
6959 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6960 inner_depth.increment()?;
6961 }
6962 let val_ref = self.pixel_format.get_or_insert_with(|| {
6963 fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D)
6964 });
6965 fidl::decode!(
6966 fidl_fuchsia_images2__common::PixelFormat,
6967 D,
6968 val_ref,
6969 decoder,
6970 inner_offset,
6971 inner_depth
6972 )?;
6973 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6974 {
6975 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6976 }
6977 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6978 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6979 }
6980 }
6981
6982 next_offset += envelope_size;
6983 _next_ordinal_to_read += 1;
6984 if next_offset >= end_offset {
6985 return Ok(());
6986 }
6987
6988 while _next_ordinal_to_read < 2 {
6990 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6991 _next_ordinal_to_read += 1;
6992 next_offset += envelope_size;
6993 }
6994
6995 let next_out_of_line = decoder.next_out_of_line();
6996 let handles_before = decoder.remaining_handles();
6997 if let Some((inlined, num_bytes, num_handles)) =
6998 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6999 {
7000 let member_inline_size = <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7001 if inlined != (member_inline_size <= 4) {
7002 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7003 }
7004 let inner_offset;
7005 let mut inner_depth = depth.clone();
7006 if inlined {
7007 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7008 inner_offset = next_offset;
7009 } else {
7010 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7011 inner_depth.increment()?;
7012 }
7013 let val_ref = self.pixel_format_modifier.get_or_insert_with(|| {
7014 fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormatModifier, D)
7015 });
7016 fidl::decode!(
7017 fidl_fuchsia_images2__common::PixelFormatModifier,
7018 D,
7019 val_ref,
7020 decoder,
7021 inner_offset,
7022 inner_depth
7023 )?;
7024 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7025 {
7026 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7027 }
7028 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7029 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7030 }
7031 }
7032
7033 next_offset += envelope_size;
7034 _next_ordinal_to_read += 1;
7035 if next_offset >= end_offset {
7036 return Ok(());
7037 }
7038
7039 while _next_ordinal_to_read < 3 {
7041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7042 _next_ordinal_to_read += 1;
7043 next_offset += envelope_size;
7044 }
7045
7046 let next_out_of_line = decoder.next_out_of_line();
7047 let handles_before = decoder.remaining_handles();
7048 if let Some((inlined, num_bytes, num_handles)) =
7049 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7050 {
7051 let member_inline_size = <fidl::encoding::Vector<
7052 fidl_fuchsia_images2__common::ColorSpace,
7053 32,
7054 > as fidl::encoding::TypeMarker>::inline_size(
7055 decoder.context
7056 );
7057 if inlined != (member_inline_size <= 4) {
7058 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7059 }
7060 let inner_offset;
7061 let mut inner_depth = depth.clone();
7062 if inlined {
7063 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7064 inner_offset = next_offset;
7065 } else {
7066 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7067 inner_depth.increment()?;
7068 }
7069 let val_ref =
7070 self.color_spaces.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D));
7071 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
7072 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7073 {
7074 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7075 }
7076 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7077 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7078 }
7079 }
7080
7081 next_offset += envelope_size;
7082 _next_ordinal_to_read += 1;
7083 if next_offset >= end_offset {
7084 return Ok(());
7085 }
7086
7087 while _next_ordinal_to_read < 4 {
7089 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7090 _next_ordinal_to_read += 1;
7091 next_offset += envelope_size;
7092 }
7093
7094 let next_out_of_line = decoder.next_out_of_line();
7095 let handles_before = decoder.remaining_handles();
7096 if let Some((inlined, num_bytes, num_handles)) =
7097 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7098 {
7099 let member_inline_size =
7100 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7101 decoder.context,
7102 );
7103 if inlined != (member_inline_size <= 4) {
7104 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7105 }
7106 let inner_offset;
7107 let mut inner_depth = depth.clone();
7108 if inlined {
7109 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7110 inner_offset = next_offset;
7111 } else {
7112 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7113 inner_depth.increment()?;
7114 }
7115 let val_ref = self
7116 .min_size
7117 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7118 fidl::decode!(
7119 fidl_fuchsia_math__common::SizeU,
7120 D,
7121 val_ref,
7122 decoder,
7123 inner_offset,
7124 inner_depth
7125 )?;
7126 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7127 {
7128 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7129 }
7130 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7131 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7132 }
7133 }
7134
7135 next_offset += envelope_size;
7136 _next_ordinal_to_read += 1;
7137 if next_offset >= end_offset {
7138 return Ok(());
7139 }
7140
7141 while _next_ordinal_to_read < 5 {
7143 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7144 _next_ordinal_to_read += 1;
7145 next_offset += envelope_size;
7146 }
7147
7148 let next_out_of_line = decoder.next_out_of_line();
7149 let handles_before = decoder.remaining_handles();
7150 if let Some((inlined, num_bytes, num_handles)) =
7151 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7152 {
7153 let member_inline_size =
7154 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7155 decoder.context,
7156 );
7157 if inlined != (member_inline_size <= 4) {
7158 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7159 }
7160 let inner_offset;
7161 let mut inner_depth = depth.clone();
7162 if inlined {
7163 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7164 inner_offset = next_offset;
7165 } else {
7166 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7167 inner_depth.increment()?;
7168 }
7169 let val_ref = self
7170 .max_size
7171 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7172 fidl::decode!(
7173 fidl_fuchsia_math__common::SizeU,
7174 D,
7175 val_ref,
7176 decoder,
7177 inner_offset,
7178 inner_depth
7179 )?;
7180 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7181 {
7182 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7183 }
7184 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7185 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7186 }
7187 }
7188
7189 next_offset += envelope_size;
7190 _next_ordinal_to_read += 1;
7191 if next_offset >= end_offset {
7192 return Ok(());
7193 }
7194
7195 while _next_ordinal_to_read < 6 {
7197 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7198 _next_ordinal_to_read += 1;
7199 next_offset += envelope_size;
7200 }
7201
7202 let next_out_of_line = decoder.next_out_of_line();
7203 let handles_before = decoder.remaining_handles();
7204 if let Some((inlined, num_bytes, num_handles)) =
7205 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7206 {
7207 let member_inline_size =
7208 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7209 if inlined != (member_inline_size <= 4) {
7210 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7211 }
7212 let inner_offset;
7213 let mut inner_depth = depth.clone();
7214 if inlined {
7215 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7216 inner_offset = next_offset;
7217 } else {
7218 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7219 inner_depth.increment()?;
7220 }
7221 let val_ref =
7222 self.min_bytes_per_row.get_or_insert_with(|| fidl::new_empty!(u32, D));
7223 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7224 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7225 {
7226 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7227 }
7228 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7229 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7230 }
7231 }
7232
7233 next_offset += envelope_size;
7234 _next_ordinal_to_read += 1;
7235 if next_offset >= end_offset {
7236 return Ok(());
7237 }
7238
7239 while _next_ordinal_to_read < 7 {
7241 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7242 _next_ordinal_to_read += 1;
7243 next_offset += envelope_size;
7244 }
7245
7246 let next_out_of_line = decoder.next_out_of_line();
7247 let handles_before = decoder.remaining_handles();
7248 if let Some((inlined, num_bytes, num_handles)) =
7249 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7250 {
7251 let member_inline_size =
7252 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7253 if inlined != (member_inline_size <= 4) {
7254 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7255 }
7256 let inner_offset;
7257 let mut inner_depth = depth.clone();
7258 if inlined {
7259 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7260 inner_offset = next_offset;
7261 } else {
7262 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7263 inner_depth.increment()?;
7264 }
7265 let val_ref =
7266 self.max_bytes_per_row.get_or_insert_with(|| fidl::new_empty!(u32, D));
7267 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7268 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7269 {
7270 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7271 }
7272 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7273 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7274 }
7275 }
7276
7277 next_offset += envelope_size;
7278 _next_ordinal_to_read += 1;
7279 if next_offset >= end_offset {
7280 return Ok(());
7281 }
7282
7283 while _next_ordinal_to_read < 8 {
7285 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7286 _next_ordinal_to_read += 1;
7287 next_offset += envelope_size;
7288 }
7289
7290 let next_out_of_line = decoder.next_out_of_line();
7291 let handles_before = decoder.remaining_handles();
7292 if let Some((inlined, num_bytes, num_handles)) =
7293 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7294 {
7295 let member_inline_size =
7296 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7297 if inlined != (member_inline_size <= 4) {
7298 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7299 }
7300 let inner_offset;
7301 let mut inner_depth = depth.clone();
7302 if inlined {
7303 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7304 inner_offset = next_offset;
7305 } else {
7306 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7307 inner_depth.increment()?;
7308 }
7309 let val_ref =
7310 self.max_width_times_height.get_or_insert_with(|| fidl::new_empty!(u64, D));
7311 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7312 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7313 {
7314 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7315 }
7316 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7317 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7318 }
7319 }
7320
7321 next_offset += envelope_size;
7322 _next_ordinal_to_read += 1;
7323 if next_offset >= end_offset {
7324 return Ok(());
7325 }
7326
7327 while _next_ordinal_to_read < 9 {
7329 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7330 _next_ordinal_to_read += 1;
7331 next_offset += envelope_size;
7332 }
7333
7334 let next_out_of_line = decoder.next_out_of_line();
7335 let handles_before = decoder.remaining_handles();
7336 if let Some((inlined, num_bytes, num_handles)) =
7337 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7338 {
7339 let member_inline_size =
7340 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7341 decoder.context,
7342 );
7343 if inlined != (member_inline_size <= 4) {
7344 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7345 }
7346 let inner_offset;
7347 let mut inner_depth = depth.clone();
7348 if inlined {
7349 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7350 inner_offset = next_offset;
7351 } else {
7352 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7353 inner_depth.increment()?;
7354 }
7355 let val_ref = self
7356 .size_alignment
7357 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7358 fidl::decode!(
7359 fidl_fuchsia_math__common::SizeU,
7360 D,
7361 val_ref,
7362 decoder,
7363 inner_offset,
7364 inner_depth
7365 )?;
7366 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7367 {
7368 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7369 }
7370 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7371 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7372 }
7373 }
7374
7375 next_offset += envelope_size;
7376 _next_ordinal_to_read += 1;
7377 if next_offset >= end_offset {
7378 return Ok(());
7379 }
7380
7381 while _next_ordinal_to_read < 10 {
7383 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7384 _next_ordinal_to_read += 1;
7385 next_offset += envelope_size;
7386 }
7387
7388 let next_out_of_line = decoder.next_out_of_line();
7389 let handles_before = decoder.remaining_handles();
7390 if let Some((inlined, num_bytes, num_handles)) =
7391 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7392 {
7393 let member_inline_size =
7394 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7395 decoder.context,
7396 );
7397 if inlined != (member_inline_size <= 4) {
7398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7399 }
7400 let inner_offset;
7401 let mut inner_depth = depth.clone();
7402 if inlined {
7403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7404 inner_offset = next_offset;
7405 } else {
7406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7407 inner_depth.increment()?;
7408 }
7409 let val_ref = self
7410 .display_rect_alignment
7411 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7412 fidl::decode!(
7413 fidl_fuchsia_math__common::SizeU,
7414 D,
7415 val_ref,
7416 decoder,
7417 inner_offset,
7418 inner_depth
7419 )?;
7420 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7421 {
7422 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7423 }
7424 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7425 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7426 }
7427 }
7428
7429 next_offset += envelope_size;
7430 _next_ordinal_to_read += 1;
7431 if next_offset >= end_offset {
7432 return Ok(());
7433 }
7434
7435 while _next_ordinal_to_read < 11 {
7437 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7438 _next_ordinal_to_read += 1;
7439 next_offset += envelope_size;
7440 }
7441
7442 let next_out_of_line = decoder.next_out_of_line();
7443 let handles_before = decoder.remaining_handles();
7444 if let Some((inlined, num_bytes, num_handles)) =
7445 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7446 {
7447 let member_inline_size =
7448 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7449 decoder.context,
7450 );
7451 if inlined != (member_inline_size <= 4) {
7452 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7453 }
7454 let inner_offset;
7455 let mut inner_depth = depth.clone();
7456 if inlined {
7457 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7458 inner_offset = next_offset;
7459 } else {
7460 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7461 inner_depth.increment()?;
7462 }
7463 let val_ref = self
7464 .required_min_size
7465 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7466 fidl::decode!(
7467 fidl_fuchsia_math__common::SizeU,
7468 D,
7469 val_ref,
7470 decoder,
7471 inner_offset,
7472 inner_depth
7473 )?;
7474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7475 {
7476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7477 }
7478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7480 }
7481 }
7482
7483 next_offset += envelope_size;
7484 _next_ordinal_to_read += 1;
7485 if next_offset >= end_offset {
7486 return Ok(());
7487 }
7488
7489 while _next_ordinal_to_read < 12 {
7491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7492 _next_ordinal_to_read += 1;
7493 next_offset += envelope_size;
7494 }
7495
7496 let next_out_of_line = decoder.next_out_of_line();
7497 let handles_before = decoder.remaining_handles();
7498 if let Some((inlined, num_bytes, num_handles)) =
7499 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7500 {
7501 let member_inline_size =
7502 <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7503 decoder.context,
7504 );
7505 if inlined != (member_inline_size <= 4) {
7506 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507 }
7508 let inner_offset;
7509 let mut inner_depth = depth.clone();
7510 if inlined {
7511 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512 inner_offset = next_offset;
7513 } else {
7514 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515 inner_depth.increment()?;
7516 }
7517 let val_ref = self
7518 .required_max_size
7519 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7520 fidl::decode!(
7521 fidl_fuchsia_math__common::SizeU,
7522 D,
7523 val_ref,
7524 decoder,
7525 inner_offset,
7526 inner_depth
7527 )?;
7528 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7529 {
7530 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7531 }
7532 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7533 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7534 }
7535 }
7536
7537 next_offset += envelope_size;
7538 _next_ordinal_to_read += 1;
7539 if next_offset >= end_offset {
7540 return Ok(());
7541 }
7542
7543 while _next_ordinal_to_read < 13 {
7545 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7546 _next_ordinal_to_read += 1;
7547 next_offset += envelope_size;
7548 }
7549
7550 let next_out_of_line = decoder.next_out_of_line();
7551 let handles_before = decoder.remaining_handles();
7552 if let Some((inlined, num_bytes, num_handles)) =
7553 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7554 {
7555 let member_inline_size =
7556 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7557 if inlined != (member_inline_size <= 4) {
7558 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7559 }
7560 let inner_offset;
7561 let mut inner_depth = depth.clone();
7562 if inlined {
7563 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7564 inner_offset = next_offset;
7565 } else {
7566 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7567 inner_depth.increment()?;
7568 }
7569 let val_ref =
7570 self.bytes_per_row_divisor.get_or_insert_with(|| fidl::new_empty!(u32, D));
7571 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7572 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7573 {
7574 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7575 }
7576 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7577 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7578 }
7579 }
7580
7581 next_offset += envelope_size;
7582 _next_ordinal_to_read += 1;
7583 if next_offset >= end_offset {
7584 return Ok(());
7585 }
7586
7587 while _next_ordinal_to_read < 14 {
7589 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7590 _next_ordinal_to_read += 1;
7591 next_offset += envelope_size;
7592 }
7593
7594 let next_out_of_line = decoder.next_out_of_line();
7595 let handles_before = decoder.remaining_handles();
7596 if let Some((inlined, num_bytes, num_handles)) =
7597 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7598 {
7599 let member_inline_size =
7600 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7601 if inlined != (member_inline_size <= 4) {
7602 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7603 }
7604 let inner_offset;
7605 let mut inner_depth = depth.clone();
7606 if inlined {
7607 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7608 inner_offset = next_offset;
7609 } else {
7610 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7611 inner_depth.increment()?;
7612 }
7613 let val_ref =
7614 self.start_offset_divisor.get_or_insert_with(|| fidl::new_empty!(u32, D));
7615 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7617 {
7618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7619 }
7620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7622 }
7623 }
7624
7625 next_offset += envelope_size;
7626 _next_ordinal_to_read += 1;
7627 if next_offset >= end_offset {
7628 return Ok(());
7629 }
7630
7631 while _next_ordinal_to_read < 15 {
7633 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7634 _next_ordinal_to_read += 1;
7635 next_offset += envelope_size;
7636 }
7637
7638 let next_out_of_line = decoder.next_out_of_line();
7639 let handles_before = decoder.remaining_handles();
7640 if let Some((inlined, num_bytes, num_handles)) =
7641 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7642 {
7643 let member_inline_size = <fidl::encoding::Vector<PixelFormatAndModifier, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7644 if inlined != (member_inline_size <= 4) {
7645 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7646 }
7647 let inner_offset;
7648 let mut inner_depth = depth.clone();
7649 if inlined {
7650 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7651 inner_offset = next_offset;
7652 } else {
7653 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7654 inner_depth.increment()?;
7655 }
7656 let val_ref = self.pixel_format_and_modifiers.get_or_insert_with(
7657 || fidl::new_empty!(fidl::encoding::Vector<PixelFormatAndModifier, 64>, D),
7658 );
7659 fidl::decode!(fidl::encoding::Vector<PixelFormatAndModifier, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
7660 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7661 {
7662 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7663 }
7664 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7665 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7666 }
7667 }
7668
7669 next_offset += envelope_size;
7670 _next_ordinal_to_read += 1;
7671 if next_offset >= end_offset {
7672 return Ok(());
7673 }
7674
7675 while _next_ordinal_to_read < 16 {
7677 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7678 _next_ordinal_to_read += 1;
7679 next_offset += envelope_size;
7680 }
7681
7682 let next_out_of_line = decoder.next_out_of_line();
7683 let handles_before = decoder.remaining_handles();
7684 if let Some((inlined, num_bytes, num_handles)) =
7685 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7686 {
7687 let member_inline_size =
7688 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7689 if inlined != (member_inline_size <= 4) {
7690 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7691 }
7692 let inner_offset;
7693 let mut inner_depth = depth.clone();
7694 if inlined {
7695 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7696 inner_offset = next_offset;
7697 } else {
7698 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7699 inner_depth.increment()?;
7700 }
7701 let val_ref = self
7702 .require_bytes_per_row_at_pixel_boundary
7703 .get_or_insert_with(|| fidl::new_empty!(bool, D));
7704 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7705 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7706 {
7707 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7708 }
7709 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7710 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7711 }
7712 }
7713
7714 next_offset += envelope_size;
7715 _next_ordinal_to_read += 1;
7716 if next_offset >= end_offset {
7717 return Ok(());
7718 }
7719
7720 while _next_ordinal_to_read < 17 {
7722 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7723 _next_ordinal_to_read += 1;
7724 next_offset += envelope_size;
7725 }
7726
7727 let next_out_of_line = decoder.next_out_of_line();
7728 let handles_before = decoder.remaining_handles();
7729 if let Some((inlined, num_bytes, num_handles)) =
7730 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7731 {
7732 let member_inline_size =
7733 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7734 if inlined != (member_inline_size <= 4) {
7735 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7736 }
7737 let inner_offset;
7738 let mut inner_depth = depth.clone();
7739 if inlined {
7740 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7741 inner_offset = next_offset;
7742 } else {
7743 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7744 inner_depth.increment()?;
7745 }
7746 let val_ref =
7747 self.is_alpha_present.get_or_insert_with(|| fidl::new_empty!(bool, D));
7748 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7749 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7750 {
7751 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7752 }
7753 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7754 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7755 }
7756 }
7757
7758 next_offset += envelope_size;
7759
7760 while next_offset < end_offset {
7762 _next_ordinal_to_read += 1;
7763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7764 next_offset += envelope_size;
7765 }
7766
7767 Ok(())
7768 }
7769 }
7770
7771 impl NodeSetDebugClientInfoRequest {
7772 #[inline(always)]
7773 fn max_ordinal_present(&self) -> u64 {
7774 if let Some(_) = self.id {
7775 return 2;
7776 }
7777 if let Some(_) = self.name {
7778 return 1;
7779 }
7780 0
7781 }
7782 }
7783
7784 impl fidl::encoding::ValueTypeMarker for NodeSetDebugClientInfoRequest {
7785 type Borrowed<'a> = &'a Self;
7786 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7787 value
7788 }
7789 }
7790
7791 unsafe impl fidl::encoding::TypeMarker for NodeSetDebugClientInfoRequest {
7792 type Owned = Self;
7793
7794 #[inline(always)]
7795 fn inline_align(_context: fidl::encoding::Context) -> usize {
7796 8
7797 }
7798
7799 #[inline(always)]
7800 fn inline_size(_context: fidl::encoding::Context) -> usize {
7801 16
7802 }
7803 }
7804
7805 unsafe impl<D: fidl::encoding::ResourceDialect>
7806 fidl::encoding::Encode<NodeSetDebugClientInfoRequest, D>
7807 for &NodeSetDebugClientInfoRequest
7808 {
7809 unsafe fn encode(
7810 self,
7811 encoder: &mut fidl::encoding::Encoder<'_, D>,
7812 offset: usize,
7813 mut depth: fidl::encoding::Depth,
7814 ) -> fidl::Result<()> {
7815 encoder.debug_check_bounds::<NodeSetDebugClientInfoRequest>(offset);
7816 let max_ordinal: u64 = self.max_ordinal_present();
7818 encoder.write_num(max_ordinal, offset);
7819 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7820 if max_ordinal == 0 {
7822 return Ok(());
7823 }
7824 depth.increment()?;
7825 let envelope_size = 8;
7826 let bytes_len = max_ordinal as usize * envelope_size;
7827 #[allow(unused_variables)]
7828 let offset = encoder.out_of_line_offset(bytes_len);
7829 let mut _prev_end_offset: usize = 0;
7830 if 1 > max_ordinal {
7831 return Ok(());
7832 }
7833
7834 let cur_offset: usize = (1 - 1) * envelope_size;
7837
7838 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7840
7841 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
7846 self.name.as_ref().map(
7847 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
7848 ),
7849 encoder,
7850 offset + cur_offset,
7851 depth,
7852 )?;
7853
7854 _prev_end_offset = cur_offset + envelope_size;
7855 if 2 > max_ordinal {
7856 return Ok(());
7857 }
7858
7859 let cur_offset: usize = (2 - 1) * envelope_size;
7862
7863 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7865
7866 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7871 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7872 encoder,
7873 offset + cur_offset,
7874 depth,
7875 )?;
7876
7877 _prev_end_offset = cur_offset + envelope_size;
7878
7879 Ok(())
7880 }
7881 }
7882
7883 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7884 for NodeSetDebugClientInfoRequest
7885 {
7886 #[inline(always)]
7887 fn new_empty() -> Self {
7888 Self::default()
7889 }
7890
7891 unsafe fn decode(
7892 &mut self,
7893 decoder: &mut fidl::encoding::Decoder<'_, D>,
7894 offset: usize,
7895 mut depth: fidl::encoding::Depth,
7896 ) -> fidl::Result<()> {
7897 decoder.debug_check_bounds::<Self>(offset);
7898 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7899 None => return Err(fidl::Error::NotNullable),
7900 Some(len) => len,
7901 };
7902 if len == 0 {
7904 return Ok(());
7905 };
7906 depth.increment()?;
7907 let envelope_size = 8;
7908 let bytes_len = len * envelope_size;
7909 let offset = decoder.out_of_line_offset(bytes_len)?;
7910 let mut _next_ordinal_to_read = 0;
7912 let mut next_offset = offset;
7913 let end_offset = offset + bytes_len;
7914 _next_ordinal_to_read += 1;
7915 if next_offset >= end_offset {
7916 return Ok(());
7917 }
7918
7919 while _next_ordinal_to_read < 1 {
7921 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7922 _next_ordinal_to_read += 1;
7923 next_offset += envelope_size;
7924 }
7925
7926 let next_out_of_line = decoder.next_out_of_line();
7927 let handles_before = decoder.remaining_handles();
7928 if let Some((inlined, num_bytes, num_handles)) =
7929 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7930 {
7931 let member_inline_size =
7932 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
7933 decoder.context,
7934 );
7935 if inlined != (member_inline_size <= 4) {
7936 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7937 }
7938 let inner_offset;
7939 let mut inner_depth = depth.clone();
7940 if inlined {
7941 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7942 inner_offset = next_offset;
7943 } else {
7944 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7945 inner_depth.increment()?;
7946 }
7947 let val_ref = self
7948 .name
7949 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
7950 fidl::decode!(
7951 fidl::encoding::BoundedString<256>,
7952 D,
7953 val_ref,
7954 decoder,
7955 inner_offset,
7956 inner_depth
7957 )?;
7958 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7959 {
7960 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7961 }
7962 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7963 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7964 }
7965 }
7966
7967 next_offset += envelope_size;
7968 _next_ordinal_to_read += 1;
7969 if next_offset >= end_offset {
7970 return Ok(());
7971 }
7972
7973 while _next_ordinal_to_read < 2 {
7975 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7976 _next_ordinal_to_read += 1;
7977 next_offset += envelope_size;
7978 }
7979
7980 let next_out_of_line = decoder.next_out_of_line();
7981 let handles_before = decoder.remaining_handles();
7982 if let Some((inlined, num_bytes, num_handles)) =
7983 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7984 {
7985 let member_inline_size =
7986 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7987 if inlined != (member_inline_size <= 4) {
7988 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7989 }
7990 let inner_offset;
7991 let mut inner_depth = depth.clone();
7992 if inlined {
7993 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7994 inner_offset = next_offset;
7995 } else {
7996 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7997 inner_depth.increment()?;
7998 }
7999 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
8000 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8002 {
8003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8004 }
8005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8007 }
8008 }
8009
8010 next_offset += envelope_size;
8011
8012 while next_offset < end_offset {
8014 _next_ordinal_to_read += 1;
8015 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8016 next_offset += envelope_size;
8017 }
8018
8019 Ok(())
8020 }
8021 }
8022
8023 impl NodeSetDebugTimeoutLogDeadlineRequest {
8024 #[inline(always)]
8025 fn max_ordinal_present(&self) -> u64 {
8026 if let Some(_) = self.deadline {
8027 return 1;
8028 }
8029 0
8030 }
8031 }
8032
8033 impl fidl::encoding::ValueTypeMarker for NodeSetDebugTimeoutLogDeadlineRequest {
8034 type Borrowed<'a> = &'a Self;
8035 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8036 value
8037 }
8038 }
8039
8040 unsafe impl fidl::encoding::TypeMarker for NodeSetDebugTimeoutLogDeadlineRequest {
8041 type Owned = Self;
8042
8043 #[inline(always)]
8044 fn inline_align(_context: fidl::encoding::Context) -> usize {
8045 8
8046 }
8047
8048 #[inline(always)]
8049 fn inline_size(_context: fidl::encoding::Context) -> usize {
8050 16
8051 }
8052 }
8053
8054 unsafe impl<D: fidl::encoding::ResourceDialect>
8055 fidl::encoding::Encode<NodeSetDebugTimeoutLogDeadlineRequest, D>
8056 for &NodeSetDebugTimeoutLogDeadlineRequest
8057 {
8058 unsafe fn encode(
8059 self,
8060 encoder: &mut fidl::encoding::Encoder<'_, D>,
8061 offset: usize,
8062 mut depth: fidl::encoding::Depth,
8063 ) -> fidl::Result<()> {
8064 encoder.debug_check_bounds::<NodeSetDebugTimeoutLogDeadlineRequest>(offset);
8065 let max_ordinal: u64 = self.max_ordinal_present();
8067 encoder.write_num(max_ordinal, offset);
8068 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8069 if max_ordinal == 0 {
8071 return Ok(());
8072 }
8073 depth.increment()?;
8074 let envelope_size = 8;
8075 let bytes_len = max_ordinal as usize * envelope_size;
8076 #[allow(unused_variables)]
8077 let offset = encoder.out_of_line_offset(bytes_len);
8078 let mut _prev_end_offset: usize = 0;
8079 if 1 > max_ordinal {
8080 return Ok(());
8081 }
8082
8083 let cur_offset: usize = (1 - 1) * envelope_size;
8086
8087 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8089
8090 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8095 self.deadline.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8096 encoder,
8097 offset + cur_offset,
8098 depth,
8099 )?;
8100
8101 _prev_end_offset = cur_offset + envelope_size;
8102
8103 Ok(())
8104 }
8105 }
8106
8107 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8108 for NodeSetDebugTimeoutLogDeadlineRequest
8109 {
8110 #[inline(always)]
8111 fn new_empty() -> Self {
8112 Self::default()
8113 }
8114
8115 unsafe fn decode(
8116 &mut self,
8117 decoder: &mut fidl::encoding::Decoder<'_, D>,
8118 offset: usize,
8119 mut depth: fidl::encoding::Depth,
8120 ) -> fidl::Result<()> {
8121 decoder.debug_check_bounds::<Self>(offset);
8122 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8123 None => return Err(fidl::Error::NotNullable),
8124 Some(len) => len,
8125 };
8126 if len == 0 {
8128 return Ok(());
8129 };
8130 depth.increment()?;
8131 let envelope_size = 8;
8132 let bytes_len = len * envelope_size;
8133 let offset = decoder.out_of_line_offset(bytes_len)?;
8134 let mut _next_ordinal_to_read = 0;
8136 let mut next_offset = offset;
8137 let end_offset = offset + bytes_len;
8138 _next_ordinal_to_read += 1;
8139 if next_offset >= end_offset {
8140 return Ok(());
8141 }
8142
8143 while _next_ordinal_to_read < 1 {
8145 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8146 _next_ordinal_to_read += 1;
8147 next_offset += envelope_size;
8148 }
8149
8150 let next_out_of_line = decoder.next_out_of_line();
8151 let handles_before = decoder.remaining_handles();
8152 if let Some((inlined, num_bytes, num_handles)) =
8153 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8154 {
8155 let member_inline_size =
8156 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8157 if inlined != (member_inline_size <= 4) {
8158 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8159 }
8160 let inner_offset;
8161 let mut inner_depth = depth.clone();
8162 if inlined {
8163 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8164 inner_offset = next_offset;
8165 } else {
8166 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8167 inner_depth.increment()?;
8168 }
8169 let val_ref = self.deadline.get_or_insert_with(|| fidl::new_empty!(i64, D));
8170 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8171 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8172 {
8173 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8174 }
8175 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8176 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8177 }
8178 }
8179
8180 next_offset += envelope_size;
8181
8182 while next_offset < end_offset {
8184 _next_ordinal_to_read += 1;
8185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8186 next_offset += envelope_size;
8187 }
8188
8189 Ok(())
8190 }
8191 }
8192
8193 impl NodeSetNameRequest {
8194 #[inline(always)]
8195 fn max_ordinal_present(&self) -> u64 {
8196 if let Some(_) = self.name {
8197 return 2;
8198 }
8199 if let Some(_) = self.priority {
8200 return 1;
8201 }
8202 0
8203 }
8204 }
8205
8206 impl fidl::encoding::ValueTypeMarker for NodeSetNameRequest {
8207 type Borrowed<'a> = &'a Self;
8208 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8209 value
8210 }
8211 }
8212
8213 unsafe impl fidl::encoding::TypeMarker for NodeSetNameRequest {
8214 type Owned = Self;
8215
8216 #[inline(always)]
8217 fn inline_align(_context: fidl::encoding::Context) -> usize {
8218 8
8219 }
8220
8221 #[inline(always)]
8222 fn inline_size(_context: fidl::encoding::Context) -> usize {
8223 16
8224 }
8225 }
8226
8227 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetNameRequest, D>
8228 for &NodeSetNameRequest
8229 {
8230 unsafe fn encode(
8231 self,
8232 encoder: &mut fidl::encoding::Encoder<'_, D>,
8233 offset: usize,
8234 mut depth: fidl::encoding::Depth,
8235 ) -> fidl::Result<()> {
8236 encoder.debug_check_bounds::<NodeSetNameRequest>(offset);
8237 let max_ordinal: u64 = self.max_ordinal_present();
8239 encoder.write_num(max_ordinal, offset);
8240 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8241 if max_ordinal == 0 {
8243 return Ok(());
8244 }
8245 depth.increment()?;
8246 let envelope_size = 8;
8247 let bytes_len = max_ordinal as usize * envelope_size;
8248 #[allow(unused_variables)]
8249 let offset = encoder.out_of_line_offset(bytes_len);
8250 let mut _prev_end_offset: usize = 0;
8251 if 1 > max_ordinal {
8252 return Ok(());
8253 }
8254
8255 let cur_offset: usize = (1 - 1) * envelope_size;
8258
8259 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8261
8262 fidl::encoding::encode_in_envelope_optional::<u32, D>(
8267 self.priority.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
8268 encoder,
8269 offset + cur_offset,
8270 depth,
8271 )?;
8272
8273 _prev_end_offset = cur_offset + envelope_size;
8274 if 2 > max_ordinal {
8275 return Ok(());
8276 }
8277
8278 let cur_offset: usize = (2 - 1) * envelope_size;
8281
8282 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8284
8285 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
8290 self.name.as_ref().map(
8291 <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
8292 ),
8293 encoder,
8294 offset + cur_offset,
8295 depth,
8296 )?;
8297
8298 _prev_end_offset = cur_offset + envelope_size;
8299
8300 Ok(())
8301 }
8302 }
8303
8304 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetNameRequest {
8305 #[inline(always)]
8306 fn new_empty() -> Self {
8307 Self::default()
8308 }
8309
8310 unsafe fn decode(
8311 &mut self,
8312 decoder: &mut fidl::encoding::Decoder<'_, D>,
8313 offset: usize,
8314 mut depth: fidl::encoding::Depth,
8315 ) -> fidl::Result<()> {
8316 decoder.debug_check_bounds::<Self>(offset);
8317 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8318 None => return Err(fidl::Error::NotNullable),
8319 Some(len) => len,
8320 };
8321 if len == 0 {
8323 return Ok(());
8324 };
8325 depth.increment()?;
8326 let envelope_size = 8;
8327 let bytes_len = len * envelope_size;
8328 let offset = decoder.out_of_line_offset(bytes_len)?;
8329 let mut _next_ordinal_to_read = 0;
8331 let mut next_offset = offset;
8332 let end_offset = offset + bytes_len;
8333 _next_ordinal_to_read += 1;
8334 if next_offset >= end_offset {
8335 return Ok(());
8336 }
8337
8338 while _next_ordinal_to_read < 1 {
8340 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8341 _next_ordinal_to_read += 1;
8342 next_offset += envelope_size;
8343 }
8344
8345 let next_out_of_line = decoder.next_out_of_line();
8346 let handles_before = decoder.remaining_handles();
8347 if let Some((inlined, num_bytes, num_handles)) =
8348 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8349 {
8350 let member_inline_size =
8351 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8352 if inlined != (member_inline_size <= 4) {
8353 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8354 }
8355 let inner_offset;
8356 let mut inner_depth = depth.clone();
8357 if inlined {
8358 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8359 inner_offset = next_offset;
8360 } else {
8361 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8362 inner_depth.increment()?;
8363 }
8364 let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(u32, D));
8365 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
8366 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8367 {
8368 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8369 }
8370 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8371 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8372 }
8373 }
8374
8375 next_offset += envelope_size;
8376 _next_ordinal_to_read += 1;
8377 if next_offset >= end_offset {
8378 return Ok(());
8379 }
8380
8381 while _next_ordinal_to_read < 2 {
8383 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8384 _next_ordinal_to_read += 1;
8385 next_offset += envelope_size;
8386 }
8387
8388 let next_out_of_line = decoder.next_out_of_line();
8389 let handles_before = decoder.remaining_handles();
8390 if let Some((inlined, num_bytes, num_handles)) =
8391 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8392 {
8393 let member_inline_size =
8394 <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
8395 decoder.context,
8396 );
8397 if inlined != (member_inline_size <= 4) {
8398 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8399 }
8400 let inner_offset;
8401 let mut inner_depth = depth.clone();
8402 if inlined {
8403 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8404 inner_offset = next_offset;
8405 } else {
8406 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8407 inner_depth.increment()?;
8408 }
8409 let val_ref = self
8410 .name
8411 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
8412 fidl::decode!(
8413 fidl::encoding::BoundedString<64>,
8414 D,
8415 val_ref,
8416 decoder,
8417 inner_offset,
8418 inner_depth
8419 )?;
8420 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8421 {
8422 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8423 }
8424 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8425 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8426 }
8427 }
8428
8429 next_offset += envelope_size;
8430
8431 while next_offset < end_offset {
8433 _next_ordinal_to_read += 1;
8434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8435 next_offset += envelope_size;
8436 }
8437
8438 Ok(())
8439 }
8440 }
8441
8442 impl NodeGetBufferCollectionIdResponse {
8443 #[inline(always)]
8444 fn max_ordinal_present(&self) -> u64 {
8445 if let Some(_) = self.buffer_collection_id {
8446 return 1;
8447 }
8448 0
8449 }
8450 }
8451
8452 impl fidl::encoding::ValueTypeMarker for NodeGetBufferCollectionIdResponse {
8453 type Borrowed<'a> = &'a Self;
8454 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8455 value
8456 }
8457 }
8458
8459 unsafe impl fidl::encoding::TypeMarker for NodeGetBufferCollectionIdResponse {
8460 type Owned = Self;
8461
8462 #[inline(always)]
8463 fn inline_align(_context: fidl::encoding::Context) -> usize {
8464 8
8465 }
8466
8467 #[inline(always)]
8468 fn inline_size(_context: fidl::encoding::Context) -> usize {
8469 16
8470 }
8471 }
8472
8473 unsafe impl<D: fidl::encoding::ResourceDialect>
8474 fidl::encoding::Encode<NodeGetBufferCollectionIdResponse, D>
8475 for &NodeGetBufferCollectionIdResponse
8476 {
8477 unsafe fn encode(
8478 self,
8479 encoder: &mut fidl::encoding::Encoder<'_, D>,
8480 offset: usize,
8481 mut depth: fidl::encoding::Depth,
8482 ) -> fidl::Result<()> {
8483 encoder.debug_check_bounds::<NodeGetBufferCollectionIdResponse>(offset);
8484 let max_ordinal: u64 = self.max_ordinal_present();
8486 encoder.write_num(max_ordinal, offset);
8487 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8488 if max_ordinal == 0 {
8490 return Ok(());
8491 }
8492 depth.increment()?;
8493 let envelope_size = 8;
8494 let bytes_len = max_ordinal as usize * envelope_size;
8495 #[allow(unused_variables)]
8496 let offset = encoder.out_of_line_offset(bytes_len);
8497 let mut _prev_end_offset: usize = 0;
8498 if 1 > max_ordinal {
8499 return Ok(());
8500 }
8501
8502 let cur_offset: usize = (1 - 1) * envelope_size;
8505
8506 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8508
8509 fidl::encoding::encode_in_envelope_optional::<u64, D>(
8514 self.buffer_collection_id
8515 .as_ref()
8516 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8517 encoder,
8518 offset + cur_offset,
8519 depth,
8520 )?;
8521
8522 _prev_end_offset = cur_offset + envelope_size;
8523
8524 Ok(())
8525 }
8526 }
8527
8528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8529 for NodeGetBufferCollectionIdResponse
8530 {
8531 #[inline(always)]
8532 fn new_empty() -> Self {
8533 Self::default()
8534 }
8535
8536 unsafe fn decode(
8537 &mut self,
8538 decoder: &mut fidl::encoding::Decoder<'_, D>,
8539 offset: usize,
8540 mut depth: fidl::encoding::Depth,
8541 ) -> fidl::Result<()> {
8542 decoder.debug_check_bounds::<Self>(offset);
8543 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8544 None => return Err(fidl::Error::NotNullable),
8545 Some(len) => len,
8546 };
8547 if len == 0 {
8549 return Ok(());
8550 };
8551 depth.increment()?;
8552 let envelope_size = 8;
8553 let bytes_len = len * envelope_size;
8554 let offset = decoder.out_of_line_offset(bytes_len)?;
8555 let mut _next_ordinal_to_read = 0;
8557 let mut next_offset = offset;
8558 let end_offset = offset + bytes_len;
8559 _next_ordinal_to_read += 1;
8560 if next_offset >= end_offset {
8561 return Ok(());
8562 }
8563
8564 while _next_ordinal_to_read < 1 {
8566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8567 _next_ordinal_to_read += 1;
8568 next_offset += envelope_size;
8569 }
8570
8571 let next_out_of_line = decoder.next_out_of_line();
8572 let handles_before = decoder.remaining_handles();
8573 if let Some((inlined, num_bytes, num_handles)) =
8574 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8575 {
8576 let member_inline_size =
8577 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8578 if inlined != (member_inline_size <= 4) {
8579 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8580 }
8581 let inner_offset;
8582 let mut inner_depth = depth.clone();
8583 if inlined {
8584 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8585 inner_offset = next_offset;
8586 } else {
8587 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8588 inner_depth.increment()?;
8589 }
8590 let val_ref =
8591 self.buffer_collection_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
8592 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8593 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8594 {
8595 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8596 }
8597 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8598 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8599 }
8600 }
8601
8602 next_offset += envelope_size;
8603
8604 while next_offset < end_offset {
8606 _next_ordinal_to_read += 1;
8607 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8608 next_offset += envelope_size;
8609 }
8610
8611 Ok(())
8612 }
8613 }
8614
8615 impl NodeIsAlternateForResponse {
8616 #[inline(always)]
8617 fn max_ordinal_present(&self) -> u64 {
8618 if let Some(_) = self.is_alternate {
8619 return 1;
8620 }
8621 0
8622 }
8623 }
8624
8625 impl fidl::encoding::ValueTypeMarker for NodeIsAlternateForResponse {
8626 type Borrowed<'a> = &'a Self;
8627 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8628 value
8629 }
8630 }
8631
8632 unsafe impl fidl::encoding::TypeMarker for NodeIsAlternateForResponse {
8633 type Owned = Self;
8634
8635 #[inline(always)]
8636 fn inline_align(_context: fidl::encoding::Context) -> usize {
8637 8
8638 }
8639
8640 #[inline(always)]
8641 fn inline_size(_context: fidl::encoding::Context) -> usize {
8642 16
8643 }
8644 }
8645
8646 unsafe impl<D: fidl::encoding::ResourceDialect>
8647 fidl::encoding::Encode<NodeIsAlternateForResponse, D> for &NodeIsAlternateForResponse
8648 {
8649 unsafe fn encode(
8650 self,
8651 encoder: &mut fidl::encoding::Encoder<'_, D>,
8652 offset: usize,
8653 mut depth: fidl::encoding::Depth,
8654 ) -> fidl::Result<()> {
8655 encoder.debug_check_bounds::<NodeIsAlternateForResponse>(offset);
8656 let max_ordinal: u64 = self.max_ordinal_present();
8658 encoder.write_num(max_ordinal, offset);
8659 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8660 if max_ordinal == 0 {
8662 return Ok(());
8663 }
8664 depth.increment()?;
8665 let envelope_size = 8;
8666 let bytes_len = max_ordinal as usize * envelope_size;
8667 #[allow(unused_variables)]
8668 let offset = encoder.out_of_line_offset(bytes_len);
8669 let mut _prev_end_offset: usize = 0;
8670 if 1 > max_ordinal {
8671 return Ok(());
8672 }
8673
8674 let cur_offset: usize = (1 - 1) * envelope_size;
8677
8678 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8680
8681 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8686 self.is_alternate.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8687 encoder,
8688 offset + cur_offset,
8689 depth,
8690 )?;
8691
8692 _prev_end_offset = cur_offset + envelope_size;
8693
8694 Ok(())
8695 }
8696 }
8697
8698 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8699 for NodeIsAlternateForResponse
8700 {
8701 #[inline(always)]
8702 fn new_empty() -> Self {
8703 Self::default()
8704 }
8705
8706 unsafe fn decode(
8707 &mut self,
8708 decoder: &mut fidl::encoding::Decoder<'_, D>,
8709 offset: usize,
8710 mut depth: fidl::encoding::Depth,
8711 ) -> fidl::Result<()> {
8712 decoder.debug_check_bounds::<Self>(offset);
8713 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8714 None => return Err(fidl::Error::NotNullable),
8715 Some(len) => len,
8716 };
8717 if len == 0 {
8719 return Ok(());
8720 };
8721 depth.increment()?;
8722 let envelope_size = 8;
8723 let bytes_len = len * envelope_size;
8724 let offset = decoder.out_of_line_offset(bytes_len)?;
8725 let mut _next_ordinal_to_read = 0;
8727 let mut next_offset = offset;
8728 let end_offset = offset + bytes_len;
8729 _next_ordinal_to_read += 1;
8730 if next_offset >= end_offset {
8731 return Ok(());
8732 }
8733
8734 while _next_ordinal_to_read < 1 {
8736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8737 _next_ordinal_to_read += 1;
8738 next_offset += envelope_size;
8739 }
8740
8741 let next_out_of_line = decoder.next_out_of_line();
8742 let handles_before = decoder.remaining_handles();
8743 if let Some((inlined, num_bytes, num_handles)) =
8744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8745 {
8746 let member_inline_size =
8747 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8748 if inlined != (member_inline_size <= 4) {
8749 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8750 }
8751 let inner_offset;
8752 let mut inner_depth = depth.clone();
8753 if inlined {
8754 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8755 inner_offset = next_offset;
8756 } else {
8757 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8758 inner_depth.increment()?;
8759 }
8760 let val_ref = self.is_alternate.get_or_insert_with(|| fidl::new_empty!(bool, D));
8761 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8762 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8763 {
8764 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8765 }
8766 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8767 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8768 }
8769 }
8770
8771 next_offset += envelope_size;
8772
8773 while next_offset < end_offset {
8775 _next_ordinal_to_read += 1;
8776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8777 next_offset += envelope_size;
8778 }
8779
8780 Ok(())
8781 }
8782 }
8783
8784 impl SecureHeapAndRange {
8785 #[inline(always)]
8786 fn max_ordinal_present(&self) -> u64 {
8787 if let Some(_) = self.range {
8788 return 2;
8789 }
8790 if let Some(_) = self.heap {
8791 return 1;
8792 }
8793 0
8794 }
8795 }
8796
8797 impl fidl::encoding::ValueTypeMarker for SecureHeapAndRange {
8798 type Borrowed<'a> = &'a Self;
8799 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8800 value
8801 }
8802 }
8803
8804 unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRange {
8805 type Owned = Self;
8806
8807 #[inline(always)]
8808 fn inline_align(_context: fidl::encoding::Context) -> usize {
8809 8
8810 }
8811
8812 #[inline(always)]
8813 fn inline_size(_context: fidl::encoding::Context) -> usize {
8814 16
8815 }
8816 }
8817
8818 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapAndRange, D>
8819 for &SecureHeapAndRange
8820 {
8821 unsafe fn encode(
8822 self,
8823 encoder: &mut fidl::encoding::Encoder<'_, D>,
8824 offset: usize,
8825 mut depth: fidl::encoding::Depth,
8826 ) -> fidl::Result<()> {
8827 encoder.debug_check_bounds::<SecureHeapAndRange>(offset);
8828 let max_ordinal: u64 = self.max_ordinal_present();
8830 encoder.write_num(max_ordinal, offset);
8831 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8832 if max_ordinal == 0 {
8834 return Ok(());
8835 }
8836 depth.increment()?;
8837 let envelope_size = 8;
8838 let bytes_len = max_ordinal as usize * envelope_size;
8839 #[allow(unused_variables)]
8840 let offset = encoder.out_of_line_offset(bytes_len);
8841 let mut _prev_end_offset: usize = 0;
8842 if 1 > max_ordinal {
8843 return Ok(());
8844 }
8845
8846 let cur_offset: usize = (1 - 1) * envelope_size;
8849
8850 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8852
8853 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
8858 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
8859 encoder,
8860 offset + cur_offset,
8861 depth,
8862 )?;
8863
8864 _prev_end_offset = cur_offset + envelope_size;
8865 if 2 > max_ordinal {
8866 return Ok(());
8867 }
8868
8869 let cur_offset: usize = (2 - 1) * envelope_size;
8872
8873 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8875
8876 fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
8881 self.range
8882 .as_ref()
8883 .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
8884 encoder,
8885 offset + cur_offset,
8886 depth,
8887 )?;
8888
8889 _prev_end_offset = cur_offset + envelope_size;
8890
8891 Ok(())
8892 }
8893 }
8894
8895 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapAndRange {
8896 #[inline(always)]
8897 fn new_empty() -> Self {
8898 Self::default()
8899 }
8900
8901 unsafe fn decode(
8902 &mut self,
8903 decoder: &mut fidl::encoding::Decoder<'_, D>,
8904 offset: usize,
8905 mut depth: fidl::encoding::Depth,
8906 ) -> fidl::Result<()> {
8907 decoder.debug_check_bounds::<Self>(offset);
8908 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8909 None => return Err(fidl::Error::NotNullable),
8910 Some(len) => len,
8911 };
8912 if len == 0 {
8914 return Ok(());
8915 };
8916 depth.increment()?;
8917 let envelope_size = 8;
8918 let bytes_len = len * envelope_size;
8919 let offset = decoder.out_of_line_offset(bytes_len)?;
8920 let mut _next_ordinal_to_read = 0;
8922 let mut next_offset = offset;
8923 let end_offset = offset + bytes_len;
8924 _next_ordinal_to_read += 1;
8925 if next_offset >= end_offset {
8926 return Ok(());
8927 }
8928
8929 while _next_ordinal_to_read < 1 {
8931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8932 _next_ordinal_to_read += 1;
8933 next_offset += envelope_size;
8934 }
8935
8936 let next_out_of_line = decoder.next_out_of_line();
8937 let handles_before = decoder.remaining_handles();
8938 if let Some((inlined, num_bytes, num_handles)) =
8939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8940 {
8941 let member_inline_size =
8942 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8943 if inlined != (member_inline_size <= 4) {
8944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8945 }
8946 let inner_offset;
8947 let mut inner_depth = depth.clone();
8948 if inlined {
8949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8950 inner_offset = next_offset;
8951 } else {
8952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8953 inner_depth.increment()?;
8954 }
8955 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
8956 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
8957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8958 {
8959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8960 }
8961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8963 }
8964 }
8965
8966 next_offset += envelope_size;
8967 _next_ordinal_to_read += 1;
8968 if next_offset >= end_offset {
8969 return Ok(());
8970 }
8971
8972 while _next_ordinal_to_read < 2 {
8974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8975 _next_ordinal_to_read += 1;
8976 next_offset += envelope_size;
8977 }
8978
8979 let next_out_of_line = decoder.next_out_of_line();
8980 let handles_before = decoder.remaining_handles();
8981 if let Some((inlined, num_bytes, num_handles)) =
8982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8983 {
8984 let member_inline_size =
8985 <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8986 if inlined != (member_inline_size <= 4) {
8987 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8988 }
8989 let inner_offset;
8990 let mut inner_depth = depth.clone();
8991 if inlined {
8992 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8993 inner_offset = next_offset;
8994 } else {
8995 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8996 inner_depth.increment()?;
8997 }
8998 let val_ref =
8999 self.range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9000 fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9002 {
9003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9004 }
9005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9007 }
9008 }
9009
9010 next_offset += envelope_size;
9011
9012 while next_offset < end_offset {
9014 _next_ordinal_to_read += 1;
9015 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9016 next_offset += envelope_size;
9017 }
9018
9019 Ok(())
9020 }
9021 }
9022
9023 impl SecureHeapAndRangeModification {
9024 #[inline(always)]
9025 fn max_ordinal_present(&self) -> u64 {
9026 if let Some(_) = self.new_range {
9027 return 3;
9028 }
9029 if let Some(_) = self.old_range {
9030 return 2;
9031 }
9032 if let Some(_) = self.heap {
9033 return 1;
9034 }
9035 0
9036 }
9037 }
9038
9039 impl fidl::encoding::ValueTypeMarker for SecureHeapAndRangeModification {
9040 type Borrowed<'a> = &'a Self;
9041 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9042 value
9043 }
9044 }
9045
9046 unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRangeModification {
9047 type Owned = Self;
9048
9049 #[inline(always)]
9050 fn inline_align(_context: fidl::encoding::Context) -> usize {
9051 8
9052 }
9053
9054 #[inline(always)]
9055 fn inline_size(_context: fidl::encoding::Context) -> usize {
9056 16
9057 }
9058 }
9059
9060 unsafe impl<D: fidl::encoding::ResourceDialect>
9061 fidl::encoding::Encode<SecureHeapAndRangeModification, D>
9062 for &SecureHeapAndRangeModification
9063 {
9064 unsafe fn encode(
9065 self,
9066 encoder: &mut fidl::encoding::Encoder<'_, D>,
9067 offset: usize,
9068 mut depth: fidl::encoding::Depth,
9069 ) -> fidl::Result<()> {
9070 encoder.debug_check_bounds::<SecureHeapAndRangeModification>(offset);
9071 let max_ordinal: u64 = self.max_ordinal_present();
9073 encoder.write_num(max_ordinal, offset);
9074 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9075 if max_ordinal == 0 {
9077 return Ok(());
9078 }
9079 depth.increment()?;
9080 let envelope_size = 8;
9081 let bytes_len = max_ordinal as usize * envelope_size;
9082 #[allow(unused_variables)]
9083 let offset = encoder.out_of_line_offset(bytes_len);
9084 let mut _prev_end_offset: usize = 0;
9085 if 1 > max_ordinal {
9086 return Ok(());
9087 }
9088
9089 let cur_offset: usize = (1 - 1) * envelope_size;
9092
9093 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9095
9096 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9101 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9102 encoder,
9103 offset + cur_offset,
9104 depth,
9105 )?;
9106
9107 _prev_end_offset = cur_offset + envelope_size;
9108 if 2 > max_ordinal {
9109 return Ok(());
9110 }
9111
9112 let cur_offset: usize = (2 - 1) * envelope_size;
9115
9116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9118
9119 fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
9124 self.old_range
9125 .as_ref()
9126 .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
9127 encoder,
9128 offset + cur_offset,
9129 depth,
9130 )?;
9131
9132 _prev_end_offset = cur_offset + envelope_size;
9133 if 3 > max_ordinal {
9134 return Ok(());
9135 }
9136
9137 let cur_offset: usize = (3 - 1) * envelope_size;
9140
9141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9143
9144 fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
9149 self.new_range
9150 .as_ref()
9151 .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
9152 encoder,
9153 offset + cur_offset,
9154 depth,
9155 )?;
9156
9157 _prev_end_offset = cur_offset + envelope_size;
9158
9159 Ok(())
9160 }
9161 }
9162
9163 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9164 for SecureHeapAndRangeModification
9165 {
9166 #[inline(always)]
9167 fn new_empty() -> Self {
9168 Self::default()
9169 }
9170
9171 unsafe fn decode(
9172 &mut self,
9173 decoder: &mut fidl::encoding::Decoder<'_, D>,
9174 offset: usize,
9175 mut depth: fidl::encoding::Depth,
9176 ) -> fidl::Result<()> {
9177 decoder.debug_check_bounds::<Self>(offset);
9178 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9179 None => return Err(fidl::Error::NotNullable),
9180 Some(len) => len,
9181 };
9182 if len == 0 {
9184 return Ok(());
9185 };
9186 depth.increment()?;
9187 let envelope_size = 8;
9188 let bytes_len = len * envelope_size;
9189 let offset = decoder.out_of_line_offset(bytes_len)?;
9190 let mut _next_ordinal_to_read = 0;
9192 let mut next_offset = offset;
9193 let end_offset = offset + bytes_len;
9194 _next_ordinal_to_read += 1;
9195 if next_offset >= end_offset {
9196 return Ok(());
9197 }
9198
9199 while _next_ordinal_to_read < 1 {
9201 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9202 _next_ordinal_to_read += 1;
9203 next_offset += envelope_size;
9204 }
9205
9206 let next_out_of_line = decoder.next_out_of_line();
9207 let handles_before = decoder.remaining_handles();
9208 if let Some((inlined, num_bytes, num_handles)) =
9209 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9210 {
9211 let member_inline_size =
9212 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9213 if inlined != (member_inline_size <= 4) {
9214 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9215 }
9216 let inner_offset;
9217 let mut inner_depth = depth.clone();
9218 if inlined {
9219 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9220 inner_offset = next_offset;
9221 } else {
9222 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9223 inner_depth.increment()?;
9224 }
9225 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9226 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9227 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9228 {
9229 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9230 }
9231 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9232 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9233 }
9234 }
9235
9236 next_offset += envelope_size;
9237 _next_ordinal_to_read += 1;
9238 if next_offset >= end_offset {
9239 return Ok(());
9240 }
9241
9242 while _next_ordinal_to_read < 2 {
9244 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9245 _next_ordinal_to_read += 1;
9246 next_offset += envelope_size;
9247 }
9248
9249 let next_out_of_line = decoder.next_out_of_line();
9250 let handles_before = decoder.remaining_handles();
9251 if let Some((inlined, num_bytes, num_handles)) =
9252 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9253 {
9254 let member_inline_size =
9255 <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9256 if inlined != (member_inline_size <= 4) {
9257 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9258 }
9259 let inner_offset;
9260 let mut inner_depth = depth.clone();
9261 if inlined {
9262 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9263 inner_offset = next_offset;
9264 } else {
9265 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9266 inner_depth.increment()?;
9267 }
9268 let val_ref =
9269 self.old_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9270 fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9272 {
9273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9274 }
9275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9277 }
9278 }
9279
9280 next_offset += envelope_size;
9281 _next_ordinal_to_read += 1;
9282 if next_offset >= end_offset {
9283 return Ok(());
9284 }
9285
9286 while _next_ordinal_to_read < 3 {
9288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9289 _next_ordinal_to_read += 1;
9290 next_offset += envelope_size;
9291 }
9292
9293 let next_out_of_line = decoder.next_out_of_line();
9294 let handles_before = decoder.remaining_handles();
9295 if let Some((inlined, num_bytes, num_handles)) =
9296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9297 {
9298 let member_inline_size =
9299 <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9300 if inlined != (member_inline_size <= 4) {
9301 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9302 }
9303 let inner_offset;
9304 let mut inner_depth = depth.clone();
9305 if inlined {
9306 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9307 inner_offset = next_offset;
9308 } else {
9309 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9310 inner_depth.increment()?;
9311 }
9312 let val_ref =
9313 self.new_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9314 fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9315 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9316 {
9317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9318 }
9319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9321 }
9322 }
9323
9324 next_offset += envelope_size;
9325
9326 while next_offset < end_offset {
9328 _next_ordinal_to_read += 1;
9329 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9330 next_offset += envelope_size;
9331 }
9332
9333 Ok(())
9334 }
9335 }
9336
9337 impl SecureHeapAndRanges {
9338 #[inline(always)]
9339 fn max_ordinal_present(&self) -> u64 {
9340 if let Some(_) = self.ranges {
9341 return 2;
9342 }
9343 if let Some(_) = self.heap {
9344 return 1;
9345 }
9346 0
9347 }
9348 }
9349
9350 impl fidl::encoding::ValueTypeMarker for SecureHeapAndRanges {
9351 type Borrowed<'a> = &'a Self;
9352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9353 value
9354 }
9355 }
9356
9357 unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRanges {
9358 type Owned = Self;
9359
9360 #[inline(always)]
9361 fn inline_align(_context: fidl::encoding::Context) -> usize {
9362 8
9363 }
9364
9365 #[inline(always)]
9366 fn inline_size(_context: fidl::encoding::Context) -> usize {
9367 16
9368 }
9369 }
9370
9371 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapAndRanges, D>
9372 for &SecureHeapAndRanges
9373 {
9374 unsafe fn encode(
9375 self,
9376 encoder: &mut fidl::encoding::Encoder<'_, D>,
9377 offset: usize,
9378 mut depth: fidl::encoding::Depth,
9379 ) -> fidl::Result<()> {
9380 encoder.debug_check_bounds::<SecureHeapAndRanges>(offset);
9381 let max_ordinal: u64 = self.max_ordinal_present();
9383 encoder.write_num(max_ordinal, offset);
9384 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9385 if max_ordinal == 0 {
9387 return Ok(());
9388 }
9389 depth.increment()?;
9390 let envelope_size = 8;
9391 let bytes_len = max_ordinal as usize * envelope_size;
9392 #[allow(unused_variables)]
9393 let offset = encoder.out_of_line_offset(bytes_len);
9394 let mut _prev_end_offset: usize = 0;
9395 if 1 > max_ordinal {
9396 return Ok(());
9397 }
9398
9399 let cur_offset: usize = (1 - 1) * envelope_size;
9402
9403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9405
9406 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9411 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9412 encoder,
9413 offset + cur_offset,
9414 depth,
9415 )?;
9416
9417 _prev_end_offset = cur_offset + envelope_size;
9418 if 2 > max_ordinal {
9419 return Ok(());
9420 }
9421
9422 let cur_offset: usize = (2 - 1) * envelope_size;
9425
9426 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9428
9429 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SecureHeapRange, 128>, D>(
9434 self.ranges.as_ref().map(<fidl::encoding::Vector<SecureHeapRange, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9435 encoder, offset + cur_offset, depth
9436 )?;
9437
9438 _prev_end_offset = cur_offset + envelope_size;
9439
9440 Ok(())
9441 }
9442 }
9443
9444 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapAndRanges {
9445 #[inline(always)]
9446 fn new_empty() -> Self {
9447 Self::default()
9448 }
9449
9450 unsafe fn decode(
9451 &mut self,
9452 decoder: &mut fidl::encoding::Decoder<'_, D>,
9453 offset: usize,
9454 mut depth: fidl::encoding::Depth,
9455 ) -> fidl::Result<()> {
9456 decoder.debug_check_bounds::<Self>(offset);
9457 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9458 None => return Err(fidl::Error::NotNullable),
9459 Some(len) => len,
9460 };
9461 if len == 0 {
9463 return Ok(());
9464 };
9465 depth.increment()?;
9466 let envelope_size = 8;
9467 let bytes_len = len * envelope_size;
9468 let offset = decoder.out_of_line_offset(bytes_len)?;
9469 let mut _next_ordinal_to_read = 0;
9471 let mut next_offset = offset;
9472 let end_offset = offset + bytes_len;
9473 _next_ordinal_to_read += 1;
9474 if next_offset >= end_offset {
9475 return Ok(());
9476 }
9477
9478 while _next_ordinal_to_read < 1 {
9480 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9481 _next_ordinal_to_read += 1;
9482 next_offset += envelope_size;
9483 }
9484
9485 let next_out_of_line = decoder.next_out_of_line();
9486 let handles_before = decoder.remaining_handles();
9487 if let Some((inlined, num_bytes, num_handles)) =
9488 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9489 {
9490 let member_inline_size =
9491 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9492 if inlined != (member_inline_size <= 4) {
9493 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9494 }
9495 let inner_offset;
9496 let mut inner_depth = depth.clone();
9497 if inlined {
9498 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9499 inner_offset = next_offset;
9500 } else {
9501 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9502 inner_depth.increment()?;
9503 }
9504 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9505 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9506 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9507 {
9508 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9509 }
9510 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9511 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9512 }
9513 }
9514
9515 next_offset += envelope_size;
9516 _next_ordinal_to_read += 1;
9517 if next_offset >= end_offset {
9518 return Ok(());
9519 }
9520
9521 while _next_ordinal_to_read < 2 {
9523 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9524 _next_ordinal_to_read += 1;
9525 next_offset += envelope_size;
9526 }
9527
9528 let next_out_of_line = decoder.next_out_of_line();
9529 let handles_before = decoder.remaining_handles();
9530 if let Some((inlined, num_bytes, num_handles)) =
9531 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9532 {
9533 let member_inline_size = <fidl::encoding::Vector<SecureHeapRange, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9534 if inlined != (member_inline_size <= 4) {
9535 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9536 }
9537 let inner_offset;
9538 let mut inner_depth = depth.clone();
9539 if inlined {
9540 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9541 inner_offset = next_offset;
9542 } else {
9543 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9544 inner_depth.increment()?;
9545 }
9546 let val_ref = self.ranges.get_or_insert_with(
9547 || fidl::new_empty!(fidl::encoding::Vector<SecureHeapRange, 128>, D),
9548 );
9549 fidl::decode!(fidl::encoding::Vector<SecureHeapRange, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
9550 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9551 {
9552 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9553 }
9554 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9555 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9556 }
9557 }
9558
9559 next_offset += envelope_size;
9560
9561 while next_offset < end_offset {
9563 _next_ordinal_to_read += 1;
9564 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9565 next_offset += envelope_size;
9566 }
9567
9568 Ok(())
9569 }
9570 }
9571
9572 impl SecureHeapProperties {
9573 #[inline(always)]
9574 fn max_ordinal_present(&self) -> u64 {
9575 if let Some(_) = self.is_mod_protected_range_available {
9576 return 5;
9577 }
9578 if let Some(_) = self.max_protected_range_count {
9579 return 4;
9580 }
9581 if let Some(_) = self.protected_range_granularity {
9582 return 3;
9583 }
9584 if let Some(_) = self.dynamic_protection_ranges {
9585 return 2;
9586 }
9587 if let Some(_) = self.heap {
9588 return 1;
9589 }
9590 0
9591 }
9592 }
9593
9594 impl fidl::encoding::ValueTypeMarker for SecureHeapProperties {
9595 type Borrowed<'a> = &'a Self;
9596 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9597 value
9598 }
9599 }
9600
9601 unsafe impl fidl::encoding::TypeMarker for SecureHeapProperties {
9602 type Owned = Self;
9603
9604 #[inline(always)]
9605 fn inline_align(_context: fidl::encoding::Context) -> usize {
9606 8
9607 }
9608
9609 #[inline(always)]
9610 fn inline_size(_context: fidl::encoding::Context) -> usize {
9611 16
9612 }
9613 }
9614
9615 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapProperties, D>
9616 for &SecureHeapProperties
9617 {
9618 unsafe fn encode(
9619 self,
9620 encoder: &mut fidl::encoding::Encoder<'_, D>,
9621 offset: usize,
9622 mut depth: fidl::encoding::Depth,
9623 ) -> fidl::Result<()> {
9624 encoder.debug_check_bounds::<SecureHeapProperties>(offset);
9625 let max_ordinal: u64 = self.max_ordinal_present();
9627 encoder.write_num(max_ordinal, offset);
9628 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9629 if max_ordinal == 0 {
9631 return Ok(());
9632 }
9633 depth.increment()?;
9634 let envelope_size = 8;
9635 let bytes_len = max_ordinal as usize * envelope_size;
9636 #[allow(unused_variables)]
9637 let offset = encoder.out_of_line_offset(bytes_len);
9638 let mut _prev_end_offset: usize = 0;
9639 if 1 > max_ordinal {
9640 return Ok(());
9641 }
9642
9643 let cur_offset: usize = (1 - 1) * envelope_size;
9646
9647 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9649
9650 fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9655 self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9656 encoder,
9657 offset + cur_offset,
9658 depth,
9659 )?;
9660
9661 _prev_end_offset = cur_offset + envelope_size;
9662 if 2 > max_ordinal {
9663 return Ok(());
9664 }
9665
9666 let cur_offset: usize = (2 - 1) * envelope_size;
9669
9670 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9672
9673 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9678 self.dynamic_protection_ranges
9679 .as_ref()
9680 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9681 encoder,
9682 offset + cur_offset,
9683 depth,
9684 )?;
9685
9686 _prev_end_offset = cur_offset + envelope_size;
9687 if 3 > max_ordinal {
9688 return Ok(());
9689 }
9690
9691 let cur_offset: usize = (3 - 1) * envelope_size;
9694
9695 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9697
9698 fidl::encoding::encode_in_envelope_optional::<u32, D>(
9703 self.protected_range_granularity
9704 .as_ref()
9705 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9706 encoder,
9707 offset + cur_offset,
9708 depth,
9709 )?;
9710
9711 _prev_end_offset = cur_offset + envelope_size;
9712 if 4 > max_ordinal {
9713 return Ok(());
9714 }
9715
9716 let cur_offset: usize = (4 - 1) * envelope_size;
9719
9720 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9722
9723 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9728 self.max_protected_range_count
9729 .as_ref()
9730 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9731 encoder,
9732 offset + cur_offset,
9733 depth,
9734 )?;
9735
9736 _prev_end_offset = cur_offset + envelope_size;
9737 if 5 > max_ordinal {
9738 return Ok(());
9739 }
9740
9741 let cur_offset: usize = (5 - 1) * envelope_size;
9744
9745 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9747
9748 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9753 self.is_mod_protected_range_available
9754 .as_ref()
9755 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9756 encoder,
9757 offset + cur_offset,
9758 depth,
9759 )?;
9760
9761 _prev_end_offset = cur_offset + envelope_size;
9762
9763 Ok(())
9764 }
9765 }
9766
9767 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapProperties {
9768 #[inline(always)]
9769 fn new_empty() -> Self {
9770 Self::default()
9771 }
9772
9773 unsafe fn decode(
9774 &mut self,
9775 decoder: &mut fidl::encoding::Decoder<'_, D>,
9776 offset: usize,
9777 mut depth: fidl::encoding::Depth,
9778 ) -> fidl::Result<()> {
9779 decoder.debug_check_bounds::<Self>(offset);
9780 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9781 None => return Err(fidl::Error::NotNullable),
9782 Some(len) => len,
9783 };
9784 if len == 0 {
9786 return Ok(());
9787 };
9788 depth.increment()?;
9789 let envelope_size = 8;
9790 let bytes_len = len * envelope_size;
9791 let offset = decoder.out_of_line_offset(bytes_len)?;
9792 let mut _next_ordinal_to_read = 0;
9794 let mut next_offset = offset;
9795 let end_offset = offset + bytes_len;
9796 _next_ordinal_to_read += 1;
9797 if next_offset >= end_offset {
9798 return Ok(());
9799 }
9800
9801 while _next_ordinal_to_read < 1 {
9803 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9804 _next_ordinal_to_read += 1;
9805 next_offset += envelope_size;
9806 }
9807
9808 let next_out_of_line = decoder.next_out_of_line();
9809 let handles_before = decoder.remaining_handles();
9810 if let Some((inlined, num_bytes, num_handles)) =
9811 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9812 {
9813 let member_inline_size =
9814 <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9815 if inlined != (member_inline_size <= 4) {
9816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9817 }
9818 let inner_offset;
9819 let mut inner_depth = depth.clone();
9820 if inlined {
9821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9822 inner_offset = next_offset;
9823 } else {
9824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9825 inner_depth.increment()?;
9826 }
9827 let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9828 fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9829 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9830 {
9831 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9832 }
9833 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9834 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9835 }
9836 }
9837
9838 next_offset += envelope_size;
9839 _next_ordinal_to_read += 1;
9840 if next_offset >= end_offset {
9841 return Ok(());
9842 }
9843
9844 while _next_ordinal_to_read < 2 {
9846 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9847 _next_ordinal_to_read += 1;
9848 next_offset += envelope_size;
9849 }
9850
9851 let next_out_of_line = decoder.next_out_of_line();
9852 let handles_before = decoder.remaining_handles();
9853 if let Some((inlined, num_bytes, num_handles)) =
9854 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9855 {
9856 let member_inline_size =
9857 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9858 if inlined != (member_inline_size <= 4) {
9859 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9860 }
9861 let inner_offset;
9862 let mut inner_depth = depth.clone();
9863 if inlined {
9864 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9865 inner_offset = next_offset;
9866 } else {
9867 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9868 inner_depth.increment()?;
9869 }
9870 let val_ref =
9871 self.dynamic_protection_ranges.get_or_insert_with(|| fidl::new_empty!(bool, D));
9872 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9873 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9874 {
9875 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9876 }
9877 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9878 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9879 }
9880 }
9881
9882 next_offset += envelope_size;
9883 _next_ordinal_to_read += 1;
9884 if next_offset >= end_offset {
9885 return Ok(());
9886 }
9887
9888 while _next_ordinal_to_read < 3 {
9890 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9891 _next_ordinal_to_read += 1;
9892 next_offset += envelope_size;
9893 }
9894
9895 let next_out_of_line = decoder.next_out_of_line();
9896 let handles_before = decoder.remaining_handles();
9897 if let Some((inlined, num_bytes, num_handles)) =
9898 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9899 {
9900 let member_inline_size =
9901 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9902 if inlined != (member_inline_size <= 4) {
9903 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9904 }
9905 let inner_offset;
9906 let mut inner_depth = depth.clone();
9907 if inlined {
9908 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9909 inner_offset = next_offset;
9910 } else {
9911 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9912 inner_depth.increment()?;
9913 }
9914 let val_ref = self
9915 .protected_range_granularity
9916 .get_or_insert_with(|| fidl::new_empty!(u32, D));
9917 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9918 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9919 {
9920 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9921 }
9922 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9923 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9924 }
9925 }
9926
9927 next_offset += envelope_size;
9928 _next_ordinal_to_read += 1;
9929 if next_offset >= end_offset {
9930 return Ok(());
9931 }
9932
9933 while _next_ordinal_to_read < 4 {
9935 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9936 _next_ordinal_to_read += 1;
9937 next_offset += envelope_size;
9938 }
9939
9940 let next_out_of_line = decoder.next_out_of_line();
9941 let handles_before = decoder.remaining_handles();
9942 if let Some((inlined, num_bytes, num_handles)) =
9943 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9944 {
9945 let member_inline_size =
9946 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9947 if inlined != (member_inline_size <= 4) {
9948 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9949 }
9950 let inner_offset;
9951 let mut inner_depth = depth.clone();
9952 if inlined {
9953 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9954 inner_offset = next_offset;
9955 } else {
9956 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9957 inner_depth.increment()?;
9958 }
9959 let val_ref =
9960 self.max_protected_range_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
9961 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9963 {
9964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9965 }
9966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9968 }
9969 }
9970
9971 next_offset += envelope_size;
9972 _next_ordinal_to_read += 1;
9973 if next_offset >= end_offset {
9974 return Ok(());
9975 }
9976
9977 while _next_ordinal_to_read < 5 {
9979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9980 _next_ordinal_to_read += 1;
9981 next_offset += envelope_size;
9982 }
9983
9984 let next_out_of_line = decoder.next_out_of_line();
9985 let handles_before = decoder.remaining_handles();
9986 if let Some((inlined, num_bytes, num_handles)) =
9987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9988 {
9989 let member_inline_size =
9990 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9991 if inlined != (member_inline_size <= 4) {
9992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9993 }
9994 let inner_offset;
9995 let mut inner_depth = depth.clone();
9996 if inlined {
9997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9998 inner_offset = next_offset;
9999 } else {
10000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10001 inner_depth.increment()?;
10002 }
10003 let val_ref = self
10004 .is_mod_protected_range_available
10005 .get_or_insert_with(|| fidl::new_empty!(bool, D));
10006 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10007 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10008 {
10009 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10010 }
10011 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10012 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10013 }
10014 }
10015
10016 next_offset += envelope_size;
10017
10018 while next_offset < end_offset {
10020 _next_ordinal_to_read += 1;
10021 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10022 next_offset += envelope_size;
10023 }
10024
10025 Ok(())
10026 }
10027 }
10028
10029 impl SecureHeapRange {
10030 #[inline(always)]
10031 fn max_ordinal_present(&self) -> u64 {
10032 if let Some(_) = self.size_bytes {
10033 return 2;
10034 }
10035 if let Some(_) = self.physical_address {
10036 return 1;
10037 }
10038 0
10039 }
10040 }
10041
10042 impl fidl::encoding::ValueTypeMarker for SecureHeapRange {
10043 type Borrowed<'a> = &'a Self;
10044 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10045 value
10046 }
10047 }
10048
10049 unsafe impl fidl::encoding::TypeMarker for SecureHeapRange {
10050 type Owned = Self;
10051
10052 #[inline(always)]
10053 fn inline_align(_context: fidl::encoding::Context) -> usize {
10054 8
10055 }
10056
10057 #[inline(always)]
10058 fn inline_size(_context: fidl::encoding::Context) -> usize {
10059 16
10060 }
10061 }
10062
10063 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapRange, D>
10064 for &SecureHeapRange
10065 {
10066 unsafe fn encode(
10067 self,
10068 encoder: &mut fidl::encoding::Encoder<'_, D>,
10069 offset: usize,
10070 mut depth: fidl::encoding::Depth,
10071 ) -> fidl::Result<()> {
10072 encoder.debug_check_bounds::<SecureHeapRange>(offset);
10073 let max_ordinal: u64 = self.max_ordinal_present();
10075 encoder.write_num(max_ordinal, offset);
10076 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10077 if max_ordinal == 0 {
10079 return Ok(());
10080 }
10081 depth.increment()?;
10082 let envelope_size = 8;
10083 let bytes_len = max_ordinal as usize * envelope_size;
10084 #[allow(unused_variables)]
10085 let offset = encoder.out_of_line_offset(bytes_len);
10086 let mut _prev_end_offset: usize = 0;
10087 if 1 > max_ordinal {
10088 return Ok(());
10089 }
10090
10091 let cur_offset: usize = (1 - 1) * envelope_size;
10094
10095 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10097
10098 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10103 self.physical_address
10104 .as_ref()
10105 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10106 encoder,
10107 offset + cur_offset,
10108 depth,
10109 )?;
10110
10111 _prev_end_offset = cur_offset + envelope_size;
10112 if 2 > max_ordinal {
10113 return Ok(());
10114 }
10115
10116 let cur_offset: usize = (2 - 1) * envelope_size;
10119
10120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10122
10123 fidl::encoding::encode_in_envelope_optional::<u64, D>(
10128 self.size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10129 encoder,
10130 offset + cur_offset,
10131 depth,
10132 )?;
10133
10134 _prev_end_offset = cur_offset + envelope_size;
10135
10136 Ok(())
10137 }
10138 }
10139
10140 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapRange {
10141 #[inline(always)]
10142 fn new_empty() -> Self {
10143 Self::default()
10144 }
10145
10146 unsafe fn decode(
10147 &mut self,
10148 decoder: &mut fidl::encoding::Decoder<'_, D>,
10149 offset: usize,
10150 mut depth: fidl::encoding::Depth,
10151 ) -> fidl::Result<()> {
10152 decoder.debug_check_bounds::<Self>(offset);
10153 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10154 None => return Err(fidl::Error::NotNullable),
10155 Some(len) => len,
10156 };
10157 if len == 0 {
10159 return Ok(());
10160 };
10161 depth.increment()?;
10162 let envelope_size = 8;
10163 let bytes_len = len * envelope_size;
10164 let offset = decoder.out_of_line_offset(bytes_len)?;
10165 let mut _next_ordinal_to_read = 0;
10167 let mut next_offset = offset;
10168 let end_offset = offset + bytes_len;
10169 _next_ordinal_to_read += 1;
10170 if next_offset >= end_offset {
10171 return Ok(());
10172 }
10173
10174 while _next_ordinal_to_read < 1 {
10176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10177 _next_ordinal_to_read += 1;
10178 next_offset += envelope_size;
10179 }
10180
10181 let next_out_of_line = decoder.next_out_of_line();
10182 let handles_before = decoder.remaining_handles();
10183 if let Some((inlined, num_bytes, num_handles)) =
10184 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10185 {
10186 let member_inline_size =
10187 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10188 if inlined != (member_inline_size <= 4) {
10189 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10190 }
10191 let inner_offset;
10192 let mut inner_depth = depth.clone();
10193 if inlined {
10194 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10195 inner_offset = next_offset;
10196 } else {
10197 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10198 inner_depth.increment()?;
10199 }
10200 let val_ref = self.physical_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
10201 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10203 {
10204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10205 }
10206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10208 }
10209 }
10210
10211 next_offset += envelope_size;
10212 _next_ordinal_to_read += 1;
10213 if next_offset >= end_offset {
10214 return Ok(());
10215 }
10216
10217 while _next_ordinal_to_read < 2 {
10219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10220 _next_ordinal_to_read += 1;
10221 next_offset += envelope_size;
10222 }
10223
10224 let next_out_of_line = decoder.next_out_of_line();
10225 let handles_before = decoder.remaining_handles();
10226 if let Some((inlined, num_bytes, num_handles)) =
10227 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10228 {
10229 let member_inline_size =
10230 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10231 if inlined != (member_inline_size <= 4) {
10232 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10233 }
10234 let inner_offset;
10235 let mut inner_depth = depth.clone();
10236 if inlined {
10237 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10238 inner_offset = next_offset;
10239 } else {
10240 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10241 inner_depth.increment()?;
10242 }
10243 let val_ref = self.size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10244 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10246 {
10247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10248 }
10249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10251 }
10252 }
10253
10254 next_offset += envelope_size;
10255
10256 while next_offset < end_offset {
10258 _next_ordinal_to_read += 1;
10259 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10260 next_offset += envelope_size;
10261 }
10262
10263 Ok(())
10264 }
10265 }
10266
10267 impl SecureMemAddSecureHeapPhysicalRangeRequest {
10268 #[inline(always)]
10269 fn max_ordinal_present(&self) -> u64 {
10270 if let Some(_) = self.heap_range {
10271 return 1;
10272 }
10273 0
10274 }
10275 }
10276
10277 impl fidl::encoding::ValueTypeMarker for SecureMemAddSecureHeapPhysicalRangeRequest {
10278 type Borrowed<'a> = &'a Self;
10279 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10280 value
10281 }
10282 }
10283
10284 unsafe impl fidl::encoding::TypeMarker for SecureMemAddSecureHeapPhysicalRangeRequest {
10285 type Owned = Self;
10286
10287 #[inline(always)]
10288 fn inline_align(_context: fidl::encoding::Context) -> usize {
10289 8
10290 }
10291
10292 #[inline(always)]
10293 fn inline_size(_context: fidl::encoding::Context) -> usize {
10294 16
10295 }
10296 }
10297
10298 unsafe impl<D: fidl::encoding::ResourceDialect>
10299 fidl::encoding::Encode<SecureMemAddSecureHeapPhysicalRangeRequest, D>
10300 for &SecureMemAddSecureHeapPhysicalRangeRequest
10301 {
10302 unsafe fn encode(
10303 self,
10304 encoder: &mut fidl::encoding::Encoder<'_, D>,
10305 offset: usize,
10306 mut depth: fidl::encoding::Depth,
10307 ) -> fidl::Result<()> {
10308 encoder.debug_check_bounds::<SecureMemAddSecureHeapPhysicalRangeRequest>(offset);
10309 let max_ordinal: u64 = self.max_ordinal_present();
10311 encoder.write_num(max_ordinal, offset);
10312 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10313 if max_ordinal == 0 {
10315 return Ok(());
10316 }
10317 depth.increment()?;
10318 let envelope_size = 8;
10319 let bytes_len = max_ordinal as usize * envelope_size;
10320 #[allow(unused_variables)]
10321 let offset = encoder.out_of_line_offset(bytes_len);
10322 let mut _prev_end_offset: usize = 0;
10323 if 1 > max_ordinal {
10324 return Ok(());
10325 }
10326
10327 let cur_offset: usize = (1 - 1) * envelope_size;
10330
10331 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10333
10334 fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10339 self.heap_range
10340 .as_ref()
10341 .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10342 encoder,
10343 offset + cur_offset,
10344 depth,
10345 )?;
10346
10347 _prev_end_offset = cur_offset + envelope_size;
10348
10349 Ok(())
10350 }
10351 }
10352
10353 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10354 for SecureMemAddSecureHeapPhysicalRangeRequest
10355 {
10356 #[inline(always)]
10357 fn new_empty() -> Self {
10358 Self::default()
10359 }
10360
10361 unsafe fn decode(
10362 &mut self,
10363 decoder: &mut fidl::encoding::Decoder<'_, D>,
10364 offset: usize,
10365 mut depth: fidl::encoding::Depth,
10366 ) -> fidl::Result<()> {
10367 decoder.debug_check_bounds::<Self>(offset);
10368 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10369 None => return Err(fidl::Error::NotNullable),
10370 Some(len) => len,
10371 };
10372 if len == 0 {
10374 return Ok(());
10375 };
10376 depth.increment()?;
10377 let envelope_size = 8;
10378 let bytes_len = len * envelope_size;
10379 let offset = decoder.out_of_line_offset(bytes_len)?;
10380 let mut _next_ordinal_to_read = 0;
10382 let mut next_offset = offset;
10383 let end_offset = offset + bytes_len;
10384 _next_ordinal_to_read += 1;
10385 if next_offset >= end_offset {
10386 return Ok(());
10387 }
10388
10389 while _next_ordinal_to_read < 1 {
10391 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10392 _next_ordinal_to_read += 1;
10393 next_offset += envelope_size;
10394 }
10395
10396 let next_out_of_line = decoder.next_out_of_line();
10397 let handles_before = decoder.remaining_handles();
10398 if let Some((inlined, num_bytes, num_handles)) =
10399 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10400 {
10401 let member_inline_size =
10402 <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10403 decoder.context,
10404 );
10405 if inlined != (member_inline_size <= 4) {
10406 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10407 }
10408 let inner_offset;
10409 let mut inner_depth = depth.clone();
10410 if inlined {
10411 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10412 inner_offset = next_offset;
10413 } else {
10414 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10415 inner_depth.increment()?;
10416 }
10417 let val_ref =
10418 self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10419 fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10420 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10421 {
10422 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10423 }
10424 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10425 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10426 }
10427 }
10428
10429 next_offset += envelope_size;
10430
10431 while next_offset < end_offset {
10433 _next_ordinal_to_read += 1;
10434 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10435 next_offset += envelope_size;
10436 }
10437
10438 Ok(())
10439 }
10440 }
10441
10442 impl SecureMemDeleteSecureHeapPhysicalRangeRequest {
10443 #[inline(always)]
10444 fn max_ordinal_present(&self) -> u64 {
10445 if let Some(_) = self.heap_range {
10446 return 1;
10447 }
10448 0
10449 }
10450 }
10451
10452 impl fidl::encoding::ValueTypeMarker for SecureMemDeleteSecureHeapPhysicalRangeRequest {
10453 type Borrowed<'a> = &'a Self;
10454 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10455 value
10456 }
10457 }
10458
10459 unsafe impl fidl::encoding::TypeMarker for SecureMemDeleteSecureHeapPhysicalRangeRequest {
10460 type Owned = Self;
10461
10462 #[inline(always)]
10463 fn inline_align(_context: fidl::encoding::Context) -> usize {
10464 8
10465 }
10466
10467 #[inline(always)]
10468 fn inline_size(_context: fidl::encoding::Context) -> usize {
10469 16
10470 }
10471 }
10472
10473 unsafe impl<D: fidl::encoding::ResourceDialect>
10474 fidl::encoding::Encode<SecureMemDeleteSecureHeapPhysicalRangeRequest, D>
10475 for &SecureMemDeleteSecureHeapPhysicalRangeRequest
10476 {
10477 unsafe fn encode(
10478 self,
10479 encoder: &mut fidl::encoding::Encoder<'_, D>,
10480 offset: usize,
10481 mut depth: fidl::encoding::Depth,
10482 ) -> fidl::Result<()> {
10483 encoder.debug_check_bounds::<SecureMemDeleteSecureHeapPhysicalRangeRequest>(offset);
10484 let max_ordinal: u64 = self.max_ordinal_present();
10486 encoder.write_num(max_ordinal, offset);
10487 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10488 if max_ordinal == 0 {
10490 return Ok(());
10491 }
10492 depth.increment()?;
10493 let envelope_size = 8;
10494 let bytes_len = max_ordinal as usize * envelope_size;
10495 #[allow(unused_variables)]
10496 let offset = encoder.out_of_line_offset(bytes_len);
10497 let mut _prev_end_offset: usize = 0;
10498 if 1 > max_ordinal {
10499 return Ok(());
10500 }
10501
10502 let cur_offset: usize = (1 - 1) * envelope_size;
10505
10506 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10508
10509 fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10514 self.heap_range
10515 .as_ref()
10516 .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10517 encoder,
10518 offset + cur_offset,
10519 depth,
10520 )?;
10521
10522 _prev_end_offset = cur_offset + envelope_size;
10523
10524 Ok(())
10525 }
10526 }
10527
10528 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10529 for SecureMemDeleteSecureHeapPhysicalRangeRequest
10530 {
10531 #[inline(always)]
10532 fn new_empty() -> Self {
10533 Self::default()
10534 }
10535
10536 unsafe fn decode(
10537 &mut self,
10538 decoder: &mut fidl::encoding::Decoder<'_, D>,
10539 offset: usize,
10540 mut depth: fidl::encoding::Depth,
10541 ) -> fidl::Result<()> {
10542 decoder.debug_check_bounds::<Self>(offset);
10543 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10544 None => return Err(fidl::Error::NotNullable),
10545 Some(len) => len,
10546 };
10547 if len == 0 {
10549 return Ok(());
10550 };
10551 depth.increment()?;
10552 let envelope_size = 8;
10553 let bytes_len = len * envelope_size;
10554 let offset = decoder.out_of_line_offset(bytes_len)?;
10555 let mut _next_ordinal_to_read = 0;
10557 let mut next_offset = offset;
10558 let end_offset = offset + bytes_len;
10559 _next_ordinal_to_read += 1;
10560 if next_offset >= end_offset {
10561 return Ok(());
10562 }
10563
10564 while _next_ordinal_to_read < 1 {
10566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10567 _next_ordinal_to_read += 1;
10568 next_offset += envelope_size;
10569 }
10570
10571 let next_out_of_line = decoder.next_out_of_line();
10572 let handles_before = decoder.remaining_handles();
10573 if let Some((inlined, num_bytes, num_handles)) =
10574 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10575 {
10576 let member_inline_size =
10577 <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10578 decoder.context,
10579 );
10580 if inlined != (member_inline_size <= 4) {
10581 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10582 }
10583 let inner_offset;
10584 let mut inner_depth = depth.clone();
10585 if inlined {
10586 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10587 inner_offset = next_offset;
10588 } else {
10589 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10590 inner_depth.increment()?;
10591 }
10592 let val_ref =
10593 self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10594 fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10595 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10596 {
10597 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10598 }
10599 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10600 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10601 }
10602 }
10603
10604 next_offset += envelope_size;
10605
10606 while next_offset < end_offset {
10608 _next_ordinal_to_read += 1;
10609 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10610 next_offset += envelope_size;
10611 }
10612
10613 Ok(())
10614 }
10615 }
10616
10617 impl SecureMemGetPhysicalSecureHeapPropertiesRequest {
10618 #[inline(always)]
10619 fn max_ordinal_present(&self) -> u64 {
10620 if let Some(_) = self.entire_heap {
10621 return 1;
10622 }
10623 0
10624 }
10625 }
10626
10627 impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapPropertiesRequest {
10628 type Borrowed<'a> = &'a Self;
10629 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10630 value
10631 }
10632 }
10633
10634 unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapPropertiesRequest {
10635 type Owned = Self;
10636
10637 #[inline(always)]
10638 fn inline_align(_context: fidl::encoding::Context) -> usize {
10639 8
10640 }
10641
10642 #[inline(always)]
10643 fn inline_size(_context: fidl::encoding::Context) -> usize {
10644 16
10645 }
10646 }
10647
10648 unsafe impl<D: fidl::encoding::ResourceDialect>
10649 fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapPropertiesRequest, D>
10650 for &SecureMemGetPhysicalSecureHeapPropertiesRequest
10651 {
10652 unsafe fn encode(
10653 self,
10654 encoder: &mut fidl::encoding::Encoder<'_, D>,
10655 offset: usize,
10656 mut depth: fidl::encoding::Depth,
10657 ) -> fidl::Result<()> {
10658 encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapPropertiesRequest>(offset);
10659 let max_ordinal: u64 = self.max_ordinal_present();
10661 encoder.write_num(max_ordinal, offset);
10662 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10663 if max_ordinal == 0 {
10665 return Ok(());
10666 }
10667 depth.increment()?;
10668 let envelope_size = 8;
10669 let bytes_len = max_ordinal as usize * envelope_size;
10670 #[allow(unused_variables)]
10671 let offset = encoder.out_of_line_offset(bytes_len);
10672 let mut _prev_end_offset: usize = 0;
10673 if 1 > max_ordinal {
10674 return Ok(());
10675 }
10676
10677 let cur_offset: usize = (1 - 1) * envelope_size;
10680
10681 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10683
10684 fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10689 self.entire_heap
10690 .as_ref()
10691 .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10692 encoder,
10693 offset + cur_offset,
10694 depth,
10695 )?;
10696
10697 _prev_end_offset = cur_offset + envelope_size;
10698
10699 Ok(())
10700 }
10701 }
10702
10703 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10704 for SecureMemGetPhysicalSecureHeapPropertiesRequest
10705 {
10706 #[inline(always)]
10707 fn new_empty() -> Self {
10708 Self::default()
10709 }
10710
10711 unsafe fn decode(
10712 &mut self,
10713 decoder: &mut fidl::encoding::Decoder<'_, D>,
10714 offset: usize,
10715 mut depth: fidl::encoding::Depth,
10716 ) -> fidl::Result<()> {
10717 decoder.debug_check_bounds::<Self>(offset);
10718 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10719 None => return Err(fidl::Error::NotNullable),
10720 Some(len) => len,
10721 };
10722 if len == 0 {
10724 return Ok(());
10725 };
10726 depth.increment()?;
10727 let envelope_size = 8;
10728 let bytes_len = len * envelope_size;
10729 let offset = decoder.out_of_line_offset(bytes_len)?;
10730 let mut _next_ordinal_to_read = 0;
10732 let mut next_offset = offset;
10733 let end_offset = offset + bytes_len;
10734 _next_ordinal_to_read += 1;
10735 if next_offset >= end_offset {
10736 return Ok(());
10737 }
10738
10739 while _next_ordinal_to_read < 1 {
10741 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10742 _next_ordinal_to_read += 1;
10743 next_offset += envelope_size;
10744 }
10745
10746 let next_out_of_line = decoder.next_out_of_line();
10747 let handles_before = decoder.remaining_handles();
10748 if let Some((inlined, num_bytes, num_handles)) =
10749 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10750 {
10751 let member_inline_size =
10752 <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10753 decoder.context,
10754 );
10755 if inlined != (member_inline_size <= 4) {
10756 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10757 }
10758 let inner_offset;
10759 let mut inner_depth = depth.clone();
10760 if inlined {
10761 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10762 inner_offset = next_offset;
10763 } else {
10764 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10765 inner_depth.increment()?;
10766 }
10767 let val_ref =
10768 self.entire_heap.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10769 fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10770 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10771 {
10772 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10773 }
10774 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10775 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10776 }
10777 }
10778
10779 next_offset += envelope_size;
10780
10781 while next_offset < end_offset {
10783 _next_ordinal_to_read += 1;
10784 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10785 next_offset += envelope_size;
10786 }
10787
10788 Ok(())
10789 }
10790 }
10791
10792 impl SecureMemModifySecureHeapPhysicalRangeRequest {
10793 #[inline(always)]
10794 fn max_ordinal_present(&self) -> u64 {
10795 if let Some(_) = self.range_modification {
10796 return 1;
10797 }
10798 0
10799 }
10800 }
10801
10802 impl fidl::encoding::ValueTypeMarker for SecureMemModifySecureHeapPhysicalRangeRequest {
10803 type Borrowed<'a> = &'a Self;
10804 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10805 value
10806 }
10807 }
10808
10809 unsafe impl fidl::encoding::TypeMarker for SecureMemModifySecureHeapPhysicalRangeRequest {
10810 type Owned = Self;
10811
10812 #[inline(always)]
10813 fn inline_align(_context: fidl::encoding::Context) -> usize {
10814 8
10815 }
10816
10817 #[inline(always)]
10818 fn inline_size(_context: fidl::encoding::Context) -> usize {
10819 16
10820 }
10821 }
10822
10823 unsafe impl<D: fidl::encoding::ResourceDialect>
10824 fidl::encoding::Encode<SecureMemModifySecureHeapPhysicalRangeRequest, D>
10825 for &SecureMemModifySecureHeapPhysicalRangeRequest
10826 {
10827 unsafe fn encode(
10828 self,
10829 encoder: &mut fidl::encoding::Encoder<'_, D>,
10830 offset: usize,
10831 mut depth: fidl::encoding::Depth,
10832 ) -> fidl::Result<()> {
10833 encoder.debug_check_bounds::<SecureMemModifySecureHeapPhysicalRangeRequest>(offset);
10834 let max_ordinal: u64 = self.max_ordinal_present();
10836 encoder.write_num(max_ordinal, offset);
10837 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10838 if max_ordinal == 0 {
10840 return Ok(());
10841 }
10842 depth.increment()?;
10843 let envelope_size = 8;
10844 let bytes_len = max_ordinal as usize * envelope_size;
10845 #[allow(unused_variables)]
10846 let offset = encoder.out_of_line_offset(bytes_len);
10847 let mut _prev_end_offset: usize = 0;
10848 if 1 > max_ordinal {
10849 return Ok(());
10850 }
10851
10852 let cur_offset: usize = (1 - 1) * envelope_size;
10855
10856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10858
10859 fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRangeModification, D>(
10864 self.range_modification.as_ref().map(
10865 <SecureHeapAndRangeModification as fidl::encoding::ValueTypeMarker>::borrow,
10866 ),
10867 encoder,
10868 offset + cur_offset,
10869 depth,
10870 )?;
10871
10872 _prev_end_offset = cur_offset + envelope_size;
10873
10874 Ok(())
10875 }
10876 }
10877
10878 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10879 for SecureMemModifySecureHeapPhysicalRangeRequest
10880 {
10881 #[inline(always)]
10882 fn new_empty() -> Self {
10883 Self::default()
10884 }
10885
10886 unsafe fn decode(
10887 &mut self,
10888 decoder: &mut fidl::encoding::Decoder<'_, D>,
10889 offset: usize,
10890 mut depth: fidl::encoding::Depth,
10891 ) -> fidl::Result<()> {
10892 decoder.debug_check_bounds::<Self>(offset);
10893 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10894 None => return Err(fidl::Error::NotNullable),
10895 Some(len) => len,
10896 };
10897 if len == 0 {
10899 return Ok(());
10900 };
10901 depth.increment()?;
10902 let envelope_size = 8;
10903 let bytes_len = len * envelope_size;
10904 let offset = decoder.out_of_line_offset(bytes_len)?;
10905 let mut _next_ordinal_to_read = 0;
10907 let mut next_offset = offset;
10908 let end_offset = offset + bytes_len;
10909 _next_ordinal_to_read += 1;
10910 if next_offset >= end_offset {
10911 return Ok(());
10912 }
10913
10914 while _next_ordinal_to_read < 1 {
10916 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10917 _next_ordinal_to_read += 1;
10918 next_offset += envelope_size;
10919 }
10920
10921 let next_out_of_line = decoder.next_out_of_line();
10922 let handles_before = decoder.remaining_handles();
10923 if let Some((inlined, num_bytes, num_handles)) =
10924 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10925 {
10926 let member_inline_size =
10927 <SecureHeapAndRangeModification as fidl::encoding::TypeMarker>::inline_size(
10928 decoder.context,
10929 );
10930 if inlined != (member_inline_size <= 4) {
10931 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10932 }
10933 let inner_offset;
10934 let mut inner_depth = depth.clone();
10935 if inlined {
10936 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10937 inner_offset = next_offset;
10938 } else {
10939 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10940 inner_depth.increment()?;
10941 }
10942 let val_ref = self
10943 .range_modification
10944 .get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRangeModification, D));
10945 fidl::decode!(
10946 SecureHeapAndRangeModification,
10947 D,
10948 val_ref,
10949 decoder,
10950 inner_offset,
10951 inner_depth
10952 )?;
10953 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10954 {
10955 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10956 }
10957 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10958 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10959 }
10960 }
10961
10962 next_offset += envelope_size;
10963
10964 while next_offset < end_offset {
10966 _next_ordinal_to_read += 1;
10967 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10968 next_offset += envelope_size;
10969 }
10970
10971 Ok(())
10972 }
10973 }
10974
10975 impl SecureMemZeroSubRangeRequest {
10976 #[inline(always)]
10977 fn max_ordinal_present(&self) -> u64 {
10978 if let Some(_) = self.heap_range {
10979 return 2;
10980 }
10981 if let Some(_) = self.is_covering_range_explicit {
10982 return 1;
10983 }
10984 0
10985 }
10986 }
10987
10988 impl fidl::encoding::ValueTypeMarker for SecureMemZeroSubRangeRequest {
10989 type Borrowed<'a> = &'a Self;
10990 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10991 value
10992 }
10993 }
10994
10995 unsafe impl fidl::encoding::TypeMarker for SecureMemZeroSubRangeRequest {
10996 type Owned = Self;
10997
10998 #[inline(always)]
10999 fn inline_align(_context: fidl::encoding::Context) -> usize {
11000 8
11001 }
11002
11003 #[inline(always)]
11004 fn inline_size(_context: fidl::encoding::Context) -> usize {
11005 16
11006 }
11007 }
11008
11009 unsafe impl<D: fidl::encoding::ResourceDialect>
11010 fidl::encoding::Encode<SecureMemZeroSubRangeRequest, D> for &SecureMemZeroSubRangeRequest
11011 {
11012 unsafe fn encode(
11013 self,
11014 encoder: &mut fidl::encoding::Encoder<'_, D>,
11015 offset: usize,
11016 mut depth: fidl::encoding::Depth,
11017 ) -> fidl::Result<()> {
11018 encoder.debug_check_bounds::<SecureMemZeroSubRangeRequest>(offset);
11019 let max_ordinal: u64 = self.max_ordinal_present();
11021 encoder.write_num(max_ordinal, offset);
11022 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11023 if max_ordinal == 0 {
11025 return Ok(());
11026 }
11027 depth.increment()?;
11028 let envelope_size = 8;
11029 let bytes_len = max_ordinal as usize * envelope_size;
11030 #[allow(unused_variables)]
11031 let offset = encoder.out_of_line_offset(bytes_len);
11032 let mut _prev_end_offset: usize = 0;
11033 if 1 > max_ordinal {
11034 return Ok(());
11035 }
11036
11037 let cur_offset: usize = (1 - 1) * envelope_size;
11040
11041 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11043
11044 fidl::encoding::encode_in_envelope_optional::<bool, D>(
11049 self.is_covering_range_explicit
11050 .as_ref()
11051 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11052 encoder,
11053 offset + cur_offset,
11054 depth,
11055 )?;
11056
11057 _prev_end_offset = cur_offset + envelope_size;
11058 if 2 > max_ordinal {
11059 return Ok(());
11060 }
11061
11062 let cur_offset: usize = (2 - 1) * envelope_size;
11065
11066 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11068
11069 fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
11074 self.heap_range
11075 .as_ref()
11076 .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
11077 encoder,
11078 offset + cur_offset,
11079 depth,
11080 )?;
11081
11082 _prev_end_offset = cur_offset + envelope_size;
11083
11084 Ok(())
11085 }
11086 }
11087
11088 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11089 for SecureMemZeroSubRangeRequest
11090 {
11091 #[inline(always)]
11092 fn new_empty() -> Self {
11093 Self::default()
11094 }
11095
11096 unsafe fn decode(
11097 &mut self,
11098 decoder: &mut fidl::encoding::Decoder<'_, D>,
11099 offset: usize,
11100 mut depth: fidl::encoding::Depth,
11101 ) -> fidl::Result<()> {
11102 decoder.debug_check_bounds::<Self>(offset);
11103 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11104 None => return Err(fidl::Error::NotNullable),
11105 Some(len) => len,
11106 };
11107 if len == 0 {
11109 return Ok(());
11110 };
11111 depth.increment()?;
11112 let envelope_size = 8;
11113 let bytes_len = len * envelope_size;
11114 let offset = decoder.out_of_line_offset(bytes_len)?;
11115 let mut _next_ordinal_to_read = 0;
11117 let mut next_offset = offset;
11118 let end_offset = offset + bytes_len;
11119 _next_ordinal_to_read += 1;
11120 if next_offset >= end_offset {
11121 return Ok(());
11122 }
11123
11124 while _next_ordinal_to_read < 1 {
11126 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11127 _next_ordinal_to_read += 1;
11128 next_offset += envelope_size;
11129 }
11130
11131 let next_out_of_line = decoder.next_out_of_line();
11132 let handles_before = decoder.remaining_handles();
11133 if let Some((inlined, num_bytes, num_handles)) =
11134 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11135 {
11136 let member_inline_size =
11137 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11138 if inlined != (member_inline_size <= 4) {
11139 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11140 }
11141 let inner_offset;
11142 let mut inner_depth = depth.clone();
11143 if inlined {
11144 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11145 inner_offset = next_offset;
11146 } else {
11147 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11148 inner_depth.increment()?;
11149 }
11150 let val_ref = self
11151 .is_covering_range_explicit
11152 .get_or_insert_with(|| fidl::new_empty!(bool, D));
11153 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11154 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11155 {
11156 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11157 }
11158 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11159 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11160 }
11161 }
11162
11163 next_offset += envelope_size;
11164 _next_ordinal_to_read += 1;
11165 if next_offset >= end_offset {
11166 return Ok(());
11167 }
11168
11169 while _next_ordinal_to_read < 2 {
11171 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11172 _next_ordinal_to_read += 1;
11173 next_offset += envelope_size;
11174 }
11175
11176 let next_out_of_line = decoder.next_out_of_line();
11177 let handles_before = decoder.remaining_handles();
11178 if let Some((inlined, num_bytes, num_handles)) =
11179 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11180 {
11181 let member_inline_size =
11182 <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
11183 decoder.context,
11184 );
11185 if inlined != (member_inline_size <= 4) {
11186 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11187 }
11188 let inner_offset;
11189 let mut inner_depth = depth.clone();
11190 if inlined {
11191 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11192 inner_offset = next_offset;
11193 } else {
11194 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11195 inner_depth.increment()?;
11196 }
11197 let val_ref =
11198 self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
11199 fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
11200 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11201 {
11202 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11203 }
11204 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11205 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11206 }
11207 }
11208
11209 next_offset += envelope_size;
11210
11211 while next_offset < end_offset {
11213 _next_ordinal_to_read += 1;
11214 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11215 next_offset += envelope_size;
11216 }
11217
11218 Ok(())
11219 }
11220 }
11221
11222 impl SecureMemGetDynamicSecureHeapsResponse {
11223 #[inline(always)]
11224 fn max_ordinal_present(&self) -> u64 {
11225 if let Some(_) = self.heaps {
11226 return 1;
11227 }
11228 0
11229 }
11230 }
11231
11232 impl fidl::encoding::ValueTypeMarker for SecureMemGetDynamicSecureHeapsResponse {
11233 type Borrowed<'a> = &'a Self;
11234 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11235 value
11236 }
11237 }
11238
11239 unsafe impl fidl::encoding::TypeMarker for SecureMemGetDynamicSecureHeapsResponse {
11240 type Owned = Self;
11241
11242 #[inline(always)]
11243 fn inline_align(_context: fidl::encoding::Context) -> usize {
11244 8
11245 }
11246
11247 #[inline(always)]
11248 fn inline_size(_context: fidl::encoding::Context) -> usize {
11249 16
11250 }
11251 }
11252
11253 unsafe impl<D: fidl::encoding::ResourceDialect>
11254 fidl::encoding::Encode<SecureMemGetDynamicSecureHeapsResponse, D>
11255 for &SecureMemGetDynamicSecureHeapsResponse
11256 {
11257 unsafe fn encode(
11258 self,
11259 encoder: &mut fidl::encoding::Encoder<'_, D>,
11260 offset: usize,
11261 mut depth: fidl::encoding::Depth,
11262 ) -> fidl::Result<()> {
11263 encoder.debug_check_bounds::<SecureMemGetDynamicSecureHeapsResponse>(offset);
11264 let max_ordinal: u64 = self.max_ordinal_present();
11266 encoder.write_num(max_ordinal, offset);
11267 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11268 if max_ordinal == 0 {
11270 return Ok(());
11271 }
11272 depth.increment()?;
11273 let envelope_size = 8;
11274 let bytes_len = max_ordinal as usize * envelope_size;
11275 #[allow(unused_variables)]
11276 let offset = encoder.out_of_line_offset(bytes_len);
11277 let mut _prev_end_offset: usize = 0;
11278 if 1 > max_ordinal {
11279 return Ok(());
11280 }
11281
11282 let cur_offset: usize = (1 - 1) * envelope_size;
11285
11286 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11288
11289 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicSecureHeap, 32>, D>(
11294 self.heaps.as_ref().map(<fidl::encoding::Vector<DynamicSecureHeap, 32> as fidl::encoding::ValueTypeMarker>::borrow),
11295 encoder, offset + cur_offset, depth
11296 )?;
11297
11298 _prev_end_offset = cur_offset + envelope_size;
11299
11300 Ok(())
11301 }
11302 }
11303
11304 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11305 for SecureMemGetDynamicSecureHeapsResponse
11306 {
11307 #[inline(always)]
11308 fn new_empty() -> Self {
11309 Self::default()
11310 }
11311
11312 unsafe fn decode(
11313 &mut self,
11314 decoder: &mut fidl::encoding::Decoder<'_, D>,
11315 offset: usize,
11316 mut depth: fidl::encoding::Depth,
11317 ) -> fidl::Result<()> {
11318 decoder.debug_check_bounds::<Self>(offset);
11319 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11320 None => return Err(fidl::Error::NotNullable),
11321 Some(len) => len,
11322 };
11323 if len == 0 {
11325 return Ok(());
11326 };
11327 depth.increment()?;
11328 let envelope_size = 8;
11329 let bytes_len = len * envelope_size;
11330 let offset = decoder.out_of_line_offset(bytes_len)?;
11331 let mut _next_ordinal_to_read = 0;
11333 let mut next_offset = offset;
11334 let end_offset = offset + bytes_len;
11335 _next_ordinal_to_read += 1;
11336 if next_offset >= end_offset {
11337 return Ok(());
11338 }
11339
11340 while _next_ordinal_to_read < 1 {
11342 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11343 _next_ordinal_to_read += 1;
11344 next_offset += envelope_size;
11345 }
11346
11347 let next_out_of_line = decoder.next_out_of_line();
11348 let handles_before = decoder.remaining_handles();
11349 if let Some((inlined, num_bytes, num_handles)) =
11350 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11351 {
11352 let member_inline_size = <fidl::encoding::Vector<DynamicSecureHeap, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11353 if inlined != (member_inline_size <= 4) {
11354 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11355 }
11356 let inner_offset;
11357 let mut inner_depth = depth.clone();
11358 if inlined {
11359 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11360 inner_offset = next_offset;
11361 } else {
11362 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11363 inner_depth.increment()?;
11364 }
11365 let val_ref = self.heaps.get_or_insert_with(
11366 || fidl::new_empty!(fidl::encoding::Vector<DynamicSecureHeap, 32>, D),
11367 );
11368 fidl::decode!(fidl::encoding::Vector<DynamicSecureHeap, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
11369 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11370 {
11371 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11372 }
11373 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11374 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11375 }
11376 }
11377
11378 next_offset += envelope_size;
11379
11380 while next_offset < end_offset {
11382 _next_ordinal_to_read += 1;
11383 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11384 next_offset += envelope_size;
11385 }
11386
11387 Ok(())
11388 }
11389 }
11390
11391 impl SecureMemGetPhysicalSecureHeapPropertiesResponse {
11392 #[inline(always)]
11393 fn max_ordinal_present(&self) -> u64 {
11394 if let Some(_) = self.properties {
11395 return 1;
11396 }
11397 0
11398 }
11399 }
11400
11401 impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapPropertiesResponse {
11402 type Borrowed<'a> = &'a Self;
11403 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11404 value
11405 }
11406 }
11407
11408 unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapPropertiesResponse {
11409 type Owned = Self;
11410
11411 #[inline(always)]
11412 fn inline_align(_context: fidl::encoding::Context) -> usize {
11413 8
11414 }
11415
11416 #[inline(always)]
11417 fn inline_size(_context: fidl::encoding::Context) -> usize {
11418 16
11419 }
11420 }
11421
11422 unsafe impl<D: fidl::encoding::ResourceDialect>
11423 fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapPropertiesResponse, D>
11424 for &SecureMemGetPhysicalSecureHeapPropertiesResponse
11425 {
11426 unsafe fn encode(
11427 self,
11428 encoder: &mut fidl::encoding::Encoder<'_, D>,
11429 offset: usize,
11430 mut depth: fidl::encoding::Depth,
11431 ) -> fidl::Result<()> {
11432 encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapPropertiesResponse>(offset);
11433 let max_ordinal: u64 = self.max_ordinal_present();
11435 encoder.write_num(max_ordinal, offset);
11436 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11437 if max_ordinal == 0 {
11439 return Ok(());
11440 }
11441 depth.increment()?;
11442 let envelope_size = 8;
11443 let bytes_len = max_ordinal as usize * envelope_size;
11444 #[allow(unused_variables)]
11445 let offset = encoder.out_of_line_offset(bytes_len);
11446 let mut _prev_end_offset: usize = 0;
11447 if 1 > max_ordinal {
11448 return Ok(());
11449 }
11450
11451 let cur_offset: usize = (1 - 1) * envelope_size;
11454
11455 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11457
11458 fidl::encoding::encode_in_envelope_optional::<SecureHeapProperties, D>(
11463 self.properties
11464 .as_ref()
11465 .map(<SecureHeapProperties as fidl::encoding::ValueTypeMarker>::borrow),
11466 encoder,
11467 offset + cur_offset,
11468 depth,
11469 )?;
11470
11471 _prev_end_offset = cur_offset + envelope_size;
11472
11473 Ok(())
11474 }
11475 }
11476
11477 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11478 for SecureMemGetPhysicalSecureHeapPropertiesResponse
11479 {
11480 #[inline(always)]
11481 fn new_empty() -> Self {
11482 Self::default()
11483 }
11484
11485 unsafe fn decode(
11486 &mut self,
11487 decoder: &mut fidl::encoding::Decoder<'_, D>,
11488 offset: usize,
11489 mut depth: fidl::encoding::Depth,
11490 ) -> fidl::Result<()> {
11491 decoder.debug_check_bounds::<Self>(offset);
11492 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11493 None => return Err(fidl::Error::NotNullable),
11494 Some(len) => len,
11495 };
11496 if len == 0 {
11498 return Ok(());
11499 };
11500 depth.increment()?;
11501 let envelope_size = 8;
11502 let bytes_len = len * envelope_size;
11503 let offset = decoder.out_of_line_offset(bytes_len)?;
11504 let mut _next_ordinal_to_read = 0;
11506 let mut next_offset = offset;
11507 let end_offset = offset + bytes_len;
11508 _next_ordinal_to_read += 1;
11509 if next_offset >= end_offset {
11510 return Ok(());
11511 }
11512
11513 while _next_ordinal_to_read < 1 {
11515 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11516 _next_ordinal_to_read += 1;
11517 next_offset += envelope_size;
11518 }
11519
11520 let next_out_of_line = decoder.next_out_of_line();
11521 let handles_before = decoder.remaining_handles();
11522 if let Some((inlined, num_bytes, num_handles)) =
11523 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11524 {
11525 let member_inline_size =
11526 <SecureHeapProperties as fidl::encoding::TypeMarker>::inline_size(
11527 decoder.context,
11528 );
11529 if inlined != (member_inline_size <= 4) {
11530 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11531 }
11532 let inner_offset;
11533 let mut inner_depth = depth.clone();
11534 if inlined {
11535 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11536 inner_offset = next_offset;
11537 } else {
11538 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11539 inner_depth.increment()?;
11540 }
11541 let val_ref = self
11542 .properties
11543 .get_or_insert_with(|| fidl::new_empty!(SecureHeapProperties, D));
11544 fidl::decode!(
11545 SecureHeapProperties,
11546 D,
11547 val_ref,
11548 decoder,
11549 inner_offset,
11550 inner_depth
11551 )?;
11552 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11553 {
11554 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11555 }
11556 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11557 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11558 }
11559 }
11560
11561 next_offset += envelope_size;
11562
11563 while next_offset < end_offset {
11565 _next_ordinal_to_read += 1;
11566 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11567 next_offset += envelope_size;
11568 }
11569
11570 Ok(())
11571 }
11572 }
11573
11574 impl SecureMemGetPhysicalSecureHeapsResponse {
11575 #[inline(always)]
11576 fn max_ordinal_present(&self) -> u64 {
11577 if let Some(_) = self.heaps {
11578 return 1;
11579 }
11580 0
11581 }
11582 }
11583
11584 impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapsResponse {
11585 type Borrowed<'a> = &'a Self;
11586 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11587 value
11588 }
11589 }
11590
11591 unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapsResponse {
11592 type Owned = Self;
11593
11594 #[inline(always)]
11595 fn inline_align(_context: fidl::encoding::Context) -> usize {
11596 8
11597 }
11598
11599 #[inline(always)]
11600 fn inline_size(_context: fidl::encoding::Context) -> usize {
11601 16
11602 }
11603 }
11604
11605 unsafe impl<D: fidl::encoding::ResourceDialect>
11606 fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapsResponse, D>
11607 for &SecureMemGetPhysicalSecureHeapsResponse
11608 {
11609 unsafe fn encode(
11610 self,
11611 encoder: &mut fidl::encoding::Encoder<'_, D>,
11612 offset: usize,
11613 mut depth: fidl::encoding::Depth,
11614 ) -> fidl::Result<()> {
11615 encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapsResponse>(offset);
11616 let max_ordinal: u64 = self.max_ordinal_present();
11618 encoder.write_num(max_ordinal, offset);
11619 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11620 if max_ordinal == 0 {
11622 return Ok(());
11623 }
11624 depth.increment()?;
11625 let envelope_size = 8;
11626 let bytes_len = max_ordinal as usize * envelope_size;
11627 #[allow(unused_variables)]
11628 let offset = encoder.out_of_line_offset(bytes_len);
11629 let mut _prev_end_offset: usize = 0;
11630 if 1 > max_ordinal {
11631 return Ok(());
11632 }
11633
11634 let cur_offset: usize = (1 - 1) * envelope_size;
11637
11638 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11640
11641 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SecureHeapAndRanges, 32>, D>(
11646 self.heaps.as_ref().map(<fidl::encoding::Vector<SecureHeapAndRanges, 32> as fidl::encoding::ValueTypeMarker>::borrow),
11647 encoder, offset + cur_offset, depth
11648 )?;
11649
11650 _prev_end_offset = cur_offset + envelope_size;
11651
11652 Ok(())
11653 }
11654 }
11655
11656 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11657 for SecureMemGetPhysicalSecureHeapsResponse
11658 {
11659 #[inline(always)]
11660 fn new_empty() -> Self {
11661 Self::default()
11662 }
11663
11664 unsafe fn decode(
11665 &mut self,
11666 decoder: &mut fidl::encoding::Decoder<'_, D>,
11667 offset: usize,
11668 mut depth: fidl::encoding::Depth,
11669 ) -> fidl::Result<()> {
11670 decoder.debug_check_bounds::<Self>(offset);
11671 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11672 None => return Err(fidl::Error::NotNullable),
11673 Some(len) => len,
11674 };
11675 if len == 0 {
11677 return Ok(());
11678 };
11679 depth.increment()?;
11680 let envelope_size = 8;
11681 let bytes_len = len * envelope_size;
11682 let offset = decoder.out_of_line_offset(bytes_len)?;
11683 let mut _next_ordinal_to_read = 0;
11685 let mut next_offset = offset;
11686 let end_offset = offset + bytes_len;
11687 _next_ordinal_to_read += 1;
11688 if next_offset >= end_offset {
11689 return Ok(());
11690 }
11691
11692 while _next_ordinal_to_read < 1 {
11694 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11695 _next_ordinal_to_read += 1;
11696 next_offset += envelope_size;
11697 }
11698
11699 let next_out_of_line = decoder.next_out_of_line();
11700 let handles_before = decoder.remaining_handles();
11701 if let Some((inlined, num_bytes, num_handles)) =
11702 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11703 {
11704 let member_inline_size = <fidl::encoding::Vector<SecureHeapAndRanges, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11705 if inlined != (member_inline_size <= 4) {
11706 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11707 }
11708 let inner_offset;
11709 let mut inner_depth = depth.clone();
11710 if inlined {
11711 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11712 inner_offset = next_offset;
11713 } else {
11714 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11715 inner_depth.increment()?;
11716 }
11717 let val_ref = self.heaps.get_or_insert_with(
11718 || fidl::new_empty!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D),
11719 );
11720 fidl::decode!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
11721 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11722 {
11723 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11724 }
11725 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11726 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11727 }
11728 }
11729
11730 next_offset += envelope_size;
11731
11732 while next_offset < end_offset {
11734 _next_ordinal_to_read += 1;
11735 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11736 next_offset += envelope_size;
11737 }
11738
11739 Ok(())
11740 }
11741 }
11742
11743 impl SingleBufferSettings {
11744 #[inline(always)]
11745 fn max_ordinal_present(&self) -> u64 {
11746 if let Some(_) = self.image_format_constraints {
11747 return 2;
11748 }
11749 if let Some(_) = self.buffer_settings {
11750 return 1;
11751 }
11752 0
11753 }
11754 }
11755
11756 impl fidl::encoding::ValueTypeMarker for SingleBufferSettings {
11757 type Borrowed<'a> = &'a Self;
11758 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11759 value
11760 }
11761 }
11762
11763 unsafe impl fidl::encoding::TypeMarker for SingleBufferSettings {
11764 type Owned = Self;
11765
11766 #[inline(always)]
11767 fn inline_align(_context: fidl::encoding::Context) -> usize {
11768 8
11769 }
11770
11771 #[inline(always)]
11772 fn inline_size(_context: fidl::encoding::Context) -> usize {
11773 16
11774 }
11775 }
11776
11777 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SingleBufferSettings, D>
11778 for &SingleBufferSettings
11779 {
11780 unsafe fn encode(
11781 self,
11782 encoder: &mut fidl::encoding::Encoder<'_, D>,
11783 offset: usize,
11784 mut depth: fidl::encoding::Depth,
11785 ) -> fidl::Result<()> {
11786 encoder.debug_check_bounds::<SingleBufferSettings>(offset);
11787 let max_ordinal: u64 = self.max_ordinal_present();
11789 encoder.write_num(max_ordinal, offset);
11790 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11791 if max_ordinal == 0 {
11793 return Ok(());
11794 }
11795 depth.increment()?;
11796 let envelope_size = 8;
11797 let bytes_len = max_ordinal as usize * envelope_size;
11798 #[allow(unused_variables)]
11799 let offset = encoder.out_of_line_offset(bytes_len);
11800 let mut _prev_end_offset: usize = 0;
11801 if 1 > max_ordinal {
11802 return Ok(());
11803 }
11804
11805 let cur_offset: usize = (1 - 1) * envelope_size;
11808
11809 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11811
11812 fidl::encoding::encode_in_envelope_optional::<BufferMemorySettings, D>(
11817 self.buffer_settings
11818 .as_ref()
11819 .map(<BufferMemorySettings as fidl::encoding::ValueTypeMarker>::borrow),
11820 encoder,
11821 offset + cur_offset,
11822 depth,
11823 )?;
11824
11825 _prev_end_offset = cur_offset + envelope_size;
11826 if 2 > max_ordinal {
11827 return Ok(());
11828 }
11829
11830 let cur_offset: usize = (2 - 1) * envelope_size;
11833
11834 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11836
11837 fidl::encoding::encode_in_envelope_optional::<ImageFormatConstraints, D>(
11842 self.image_format_constraints
11843 .as_ref()
11844 .map(<ImageFormatConstraints as fidl::encoding::ValueTypeMarker>::borrow),
11845 encoder,
11846 offset + cur_offset,
11847 depth,
11848 )?;
11849
11850 _prev_end_offset = cur_offset + envelope_size;
11851
11852 Ok(())
11853 }
11854 }
11855
11856 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SingleBufferSettings {
11857 #[inline(always)]
11858 fn new_empty() -> Self {
11859 Self::default()
11860 }
11861
11862 unsafe fn decode(
11863 &mut self,
11864 decoder: &mut fidl::encoding::Decoder<'_, D>,
11865 offset: usize,
11866 mut depth: fidl::encoding::Depth,
11867 ) -> fidl::Result<()> {
11868 decoder.debug_check_bounds::<Self>(offset);
11869 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11870 None => return Err(fidl::Error::NotNullable),
11871 Some(len) => len,
11872 };
11873 if len == 0 {
11875 return Ok(());
11876 };
11877 depth.increment()?;
11878 let envelope_size = 8;
11879 let bytes_len = len * envelope_size;
11880 let offset = decoder.out_of_line_offset(bytes_len)?;
11881 let mut _next_ordinal_to_read = 0;
11883 let mut next_offset = offset;
11884 let end_offset = offset + bytes_len;
11885 _next_ordinal_to_read += 1;
11886 if next_offset >= end_offset {
11887 return Ok(());
11888 }
11889
11890 while _next_ordinal_to_read < 1 {
11892 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11893 _next_ordinal_to_read += 1;
11894 next_offset += envelope_size;
11895 }
11896
11897 let next_out_of_line = decoder.next_out_of_line();
11898 let handles_before = decoder.remaining_handles();
11899 if let Some((inlined, num_bytes, num_handles)) =
11900 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11901 {
11902 let member_inline_size =
11903 <BufferMemorySettings as fidl::encoding::TypeMarker>::inline_size(
11904 decoder.context,
11905 );
11906 if inlined != (member_inline_size <= 4) {
11907 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11908 }
11909 let inner_offset;
11910 let mut inner_depth = depth.clone();
11911 if inlined {
11912 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11913 inner_offset = next_offset;
11914 } else {
11915 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11916 inner_depth.increment()?;
11917 }
11918 let val_ref = self
11919 .buffer_settings
11920 .get_or_insert_with(|| fidl::new_empty!(BufferMemorySettings, D));
11921 fidl::decode!(
11922 BufferMemorySettings,
11923 D,
11924 val_ref,
11925 decoder,
11926 inner_offset,
11927 inner_depth
11928 )?;
11929 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11930 {
11931 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11932 }
11933 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11934 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11935 }
11936 }
11937
11938 next_offset += envelope_size;
11939 _next_ordinal_to_read += 1;
11940 if next_offset >= end_offset {
11941 return Ok(());
11942 }
11943
11944 while _next_ordinal_to_read < 2 {
11946 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11947 _next_ordinal_to_read += 1;
11948 next_offset += envelope_size;
11949 }
11950
11951 let next_out_of_line = decoder.next_out_of_line();
11952 let handles_before = decoder.remaining_handles();
11953 if let Some((inlined, num_bytes, num_handles)) =
11954 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11955 {
11956 let member_inline_size =
11957 <ImageFormatConstraints as fidl::encoding::TypeMarker>::inline_size(
11958 decoder.context,
11959 );
11960 if inlined != (member_inline_size <= 4) {
11961 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11962 }
11963 let inner_offset;
11964 let mut inner_depth = depth.clone();
11965 if inlined {
11966 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11967 inner_offset = next_offset;
11968 } else {
11969 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11970 inner_depth.increment()?;
11971 }
11972 let val_ref = self
11973 .image_format_constraints
11974 .get_or_insert_with(|| fidl::new_empty!(ImageFormatConstraints, D));
11975 fidl::decode!(
11976 ImageFormatConstraints,
11977 D,
11978 val_ref,
11979 decoder,
11980 inner_offset,
11981 inner_depth
11982 )?;
11983 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11984 {
11985 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11986 }
11987 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11988 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11989 }
11990 }
11991
11992 next_offset += envelope_size;
11993
11994 while next_offset < end_offset {
11996 _next_ordinal_to_read += 1;
11997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11998 next_offset += envelope_size;
11999 }
12000
12001 Ok(())
12002 }
12003 }
12004}