1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type ElementId = u64;
12
13pub type TopologyId = u64;
14
15pub const MAX_BYTES_ELEMENT_VENDOR_SPECIFIC: u32 = 4096;
16
17pub const MAX_COUNT_DYNAMICS_BANDS: u32 = 64;
18
19pub const MAX_COUNT_EQUALIZER_BANDS: u32 = 64;
20
21pub const MAX_COUNT_PROCESSING_ELEMENTS: u32 = 64;
22
23pub const MAX_COUNT_PROCESSING_ELEMENTS_EDGE_PAIRS: u32 = 64;
24
25pub const MAX_COUNT_TOPOLOGIES: u32 = 64;
26
27pub const MAX_STRING_SIZE: u32 = 256;
28
29bitflags! {
30 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
34 pub struct DynamicsSupportedControls: u64 {
35 const KNEE_WIDTH = 1;
37 const ATTACK = 2;
39 const RELEASE = 4;
41 const OUTPUT_GAIN = 8;
43 const INPUT_GAIN = 16;
45 const LOOKAHEAD = 32;
47 const LEVEL_TYPE = 64;
49 const LINKED_CHANNELS = 128;
51 const THRESHOLD_TYPE = 256;
53 }
54}
55
56impl DynamicsSupportedControls {
57 #[inline(always)]
58 pub fn from_bits_allow_unknown(bits: u64) -> Self {
59 Self::from_bits_retain(bits)
60 }
61
62 #[inline(always)]
63 pub fn has_unknown_bits(&self) -> bool {
64 self.get_unknown_bits() != 0
65 }
66
67 #[inline(always)]
68 pub fn get_unknown_bits(&self) -> u64 {
69 self.bits() & !Self::all().bits()
70 }
71}
72
73bitflags! {
74 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
76 pub struct EqualizerSupportedControls: u64 {
77 const CAN_CONTROL_FREQUENCY = 1;
79 const CAN_CONTROL_Q = 2;
81 const SUPPORTS_TYPE_PEAK = 4;
83 const SUPPORTS_TYPE_NOTCH = 8;
85 const SUPPORTS_TYPE_LOW_CUT = 16;
87 const SUPPORTS_TYPE_HIGH_CUT = 32;
89 const SUPPORTS_TYPE_LOW_SHELF = 64;
91 const SUPPORTS_TYPE_HIGH_SHELF = 128;
93 }
94}
95
96impl EqualizerSupportedControls {
97 #[inline(always)]
98 pub fn from_bits_allow_unknown(bits: u64) -> Self {
99 Self::from_bits_retain(bits)
100 }
101
102 #[inline(always)]
103 pub fn has_unknown_bits(&self) -> bool {
104 self.get_unknown_bits() != 0
105 }
106
107 #[inline(always)]
108 pub fn get_unknown_bits(&self) -> u64 {
109 self.bits() & !Self::all().bits()
110 }
111}
112
113#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
114pub enum ElementType {
115 VendorSpecific,
117 ConnectionPoint,
119 Gain,
121 AutomaticGainControl,
124 AutomaticGainLimiter,
128 Dynamics,
130 Mute,
132 Delay,
134 Equalizer,
136 SampleRateConversion,
138 Endpoint,
144 RingBuffer,
147 DaiInterconnect,
150 #[doc(hidden)]
151 __SourceBreaking { unknown_ordinal: u32 },
152}
153
154#[macro_export]
156macro_rules! ElementTypeUnknown {
157 () => {
158 _
159 };
160}
161
162impl ElementType {
163 #[inline]
164 pub fn from_primitive(prim: u32) -> Option<Self> {
165 match prim {
166 1 => Some(Self::VendorSpecific),
167 3 => Some(Self::ConnectionPoint),
168 4 => Some(Self::Gain),
169 5 => Some(Self::AutomaticGainControl),
170 6 => Some(Self::AutomaticGainLimiter),
171 7 => Some(Self::Dynamics),
172 8 => Some(Self::Mute),
173 9 => Some(Self::Delay),
174 10 => Some(Self::Equalizer),
175 11 => Some(Self::SampleRateConversion),
176 12 => Some(Self::Endpoint),
177 13 => Some(Self::RingBuffer),
178 14 => Some(Self::DaiInterconnect),
179 _ => None,
180 }
181 }
182
183 #[inline]
184 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
185 match prim {
186 1 => Self::VendorSpecific,
187 3 => Self::ConnectionPoint,
188 4 => Self::Gain,
189 5 => Self::AutomaticGainControl,
190 6 => Self::AutomaticGainLimiter,
191 7 => Self::Dynamics,
192 8 => Self::Mute,
193 9 => Self::Delay,
194 10 => Self::Equalizer,
195 11 => Self::SampleRateConversion,
196 12 => Self::Endpoint,
197 13 => Self::RingBuffer,
198 14 => Self::DaiInterconnect,
199 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
200 }
201 }
202
203 #[inline]
204 pub fn unknown() -> Self {
205 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
206 }
207
208 #[inline]
209 pub const fn into_primitive(self) -> u32 {
210 match self {
211 Self::VendorSpecific => 1,
212 Self::ConnectionPoint => 3,
213 Self::Gain => 4,
214 Self::AutomaticGainControl => 5,
215 Self::AutomaticGainLimiter => 6,
216 Self::Dynamics => 7,
217 Self::Mute => 8,
218 Self::Delay => 9,
219 Self::Equalizer => 10,
220 Self::SampleRateConversion => 11,
221 Self::Endpoint => 12,
222 Self::RingBuffer => 13,
223 Self::DaiInterconnect => 14,
224 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
225 }
226 }
227
228 #[inline]
229 pub fn is_unknown(&self) -> bool {
230 match self {
231 Self::__SourceBreaking { unknown_ordinal: _ } => true,
232 _ => false,
233 }
234 }
235}
236
237#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
243pub enum EndpointType {
244 RingBuffer,
248 DaiInterconnect,
251 #[doc(hidden)]
252 __SourceBreaking { unknown_ordinal: u8 },
253}
254
255#[macro_export]
257macro_rules! EndpointTypeUnknown {
258 () => {
259 _
260 };
261}
262
263impl EndpointType {
264 #[inline]
265 pub fn from_primitive(prim: u8) -> Option<Self> {
266 match prim {
267 1 => Some(Self::RingBuffer),
268 2 => Some(Self::DaiInterconnect),
269 _ => None,
270 }
271 }
272
273 #[inline]
274 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
275 match prim {
276 1 => Self::RingBuffer,
277 2 => Self::DaiInterconnect,
278 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
279 }
280 }
281
282 #[inline]
283 pub fn unknown() -> Self {
284 Self::__SourceBreaking { unknown_ordinal: 0xff }
285 }
286
287 #[inline]
288 pub const fn into_primitive(self) -> u8 {
289 match self {
290 Self::RingBuffer => 1,
291 Self::DaiInterconnect => 2,
292 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
293 }
294 }
295
296 #[inline]
297 pub fn is_unknown(&self) -> bool {
298 match self {
299 Self::__SourceBreaking { unknown_ordinal: _ } => true,
300 _ => false,
301 }
302 }
303}
304
305#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
307pub enum EqualizerBandType {
308 Peak,
310 Notch,
312 LowCut,
314 HighCut,
316 LowShelf,
318 HighShelf,
320 #[doc(hidden)]
321 __SourceBreaking { unknown_ordinal: u64 },
322}
323
324#[macro_export]
326macro_rules! EqualizerBandTypeUnknown {
327 () => {
328 _
329 };
330}
331
332impl EqualizerBandType {
333 #[inline]
334 pub fn from_primitive(prim: u64) -> Option<Self> {
335 match prim {
336 1 => Some(Self::Peak),
337 2 => Some(Self::Notch),
338 3 => Some(Self::LowCut),
339 4 => Some(Self::HighCut),
340 5 => Some(Self::LowShelf),
341 6 => Some(Self::HighShelf),
342 _ => None,
343 }
344 }
345
346 #[inline]
347 pub fn from_primitive_allow_unknown(prim: u64) -> Self {
348 match prim {
349 1 => Self::Peak,
350 2 => Self::Notch,
351 3 => Self::LowCut,
352 4 => Self::HighCut,
353 5 => Self::LowShelf,
354 6 => Self::HighShelf,
355 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
356 }
357 }
358
359 #[inline]
360 pub fn unknown() -> Self {
361 Self::__SourceBreaking { unknown_ordinal: 0xffffffffffffffff }
362 }
363
364 #[inline]
365 pub const fn into_primitive(self) -> u64 {
366 match self {
367 Self::Peak => 1,
368 Self::Notch => 2,
369 Self::LowCut => 3,
370 Self::HighCut => 4,
371 Self::LowShelf => 5,
372 Self::HighShelf => 6,
373 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
374 }
375 }
376
377 #[inline]
378 pub fn is_unknown(&self) -> bool {
379 match self {
380 Self::__SourceBreaking { unknown_ordinal: _ } => true,
381 _ => false,
382 }
383 }
384}
385
386#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
388pub enum GainDomain {
389 Digital,
391 Analog,
393 Mixed,
395 #[doc(hidden)]
396 __SourceBreaking { unknown_ordinal: u8 },
397}
398
399#[macro_export]
401macro_rules! GainDomainUnknown {
402 () => {
403 _
404 };
405}
406
407impl GainDomain {
408 #[inline]
409 pub fn from_primitive(prim: u8) -> Option<Self> {
410 match prim {
411 1 => Some(Self::Digital),
412 2 => Some(Self::Analog),
413 3 => Some(Self::Mixed),
414 _ => None,
415 }
416 }
417
418 #[inline]
419 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
420 match prim {
421 1 => Self::Digital,
422 2 => Self::Analog,
423 3 => Self::Mixed,
424 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
425 }
426 }
427
428 #[inline]
429 pub fn unknown() -> Self {
430 Self::__SourceBreaking { unknown_ordinal: 0xff }
431 }
432
433 #[inline]
434 pub const fn into_primitive(self) -> u8 {
435 match self {
436 Self::Digital => 1,
437 Self::Analog => 2,
438 Self::Mixed => 3,
439 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
440 }
441 }
442
443 #[inline]
444 pub fn is_unknown(&self) -> bool {
445 match self {
446 Self::__SourceBreaking { unknown_ordinal: _ } => true,
447 _ => false,
448 }
449 }
450}
451
452#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
454#[repr(u8)]
455pub enum GainType {
456 Decibels = 1,
458 Percent = 2,
460}
461
462impl GainType {
463 #[inline]
464 pub fn from_primitive(prim: u8) -> Option<Self> {
465 match prim {
466 1 => Some(Self::Decibels),
467 2 => Some(Self::Percent),
468 _ => None,
469 }
470 }
471
472 #[inline]
473 pub const fn into_primitive(self) -> u8 {
474 self as u8
475 }
476}
477
478#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
480#[repr(u8)]
481pub enum LevelType {
482 Peak = 1,
484 Rms = 2,
486}
487
488impl LevelType {
489 #[inline]
490 pub fn from_primitive(prim: u8) -> Option<Self> {
491 match prim {
492 1 => Some(Self::Peak),
493 2 => Some(Self::Rms),
494 _ => None,
495 }
496 }
497
498 #[inline]
499 pub const fn into_primitive(self) -> u8 {
500 self as u8
501 }
502}
503
504#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
506pub enum PlugDetectCapabilities {
507 Hardwired,
509 CanAsyncNotify,
511 #[doc(hidden)]
512 __SourceBreaking { unknown_ordinal: u32 },
513}
514
515#[macro_export]
517macro_rules! PlugDetectCapabilitiesUnknown {
518 () => {
519 _
520 };
521}
522
523impl PlugDetectCapabilities {
524 #[inline]
525 pub fn from_primitive(prim: u32) -> Option<Self> {
526 match prim {
527 0 => Some(Self::Hardwired),
528 1 => Some(Self::CanAsyncNotify),
529 _ => None,
530 }
531 }
532
533 #[inline]
534 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
535 match prim {
536 0 => Self::Hardwired,
537 1 => Self::CanAsyncNotify,
538 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
539 }
540 }
541
542 #[inline]
543 pub fn unknown() -> Self {
544 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
545 }
546
547 #[inline]
548 pub const fn into_primitive(self) -> u32 {
549 match self {
550 Self::Hardwired => 0,
551 Self::CanAsyncNotify => 1,
552 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
553 }
554 }
555
556 #[inline]
557 pub fn is_unknown(&self) -> bool {
558 match self {
559 Self::__SourceBreaking { unknown_ordinal: _ } => true,
560 _ => false,
561 }
562 }
563}
564
565#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
567#[repr(u8)]
568pub enum ThresholdType {
569 Above = 1,
571 Below = 2,
573}
574
575impl ThresholdType {
576 #[inline]
577 pub fn from_primitive(prim: u8) -> Option<Self> {
578 match prim {
579 1 => Some(Self::Above),
580 2 => Some(Self::Below),
581 _ => None,
582 }
583 }
584
585 #[inline]
586 pub const fn into_primitive(self) -> u8 {
587 self as u8
588 }
589}
590
591#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
595#[repr(C)]
596pub struct EdgePair {
597 pub processing_element_id_from: u64,
598 pub processing_element_id_to: u64,
599}
600
601impl fidl::Persistable for EdgePair {}
602
603#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
604#[repr(C)]
605pub struct ReaderWatchElementStateRequest {
606 pub processing_element_id: u64,
607}
608
609impl fidl::Persistable for ReaderWatchElementStateRequest {}
610
611#[derive(Clone, Debug, PartialEq)]
612pub struct ReaderWatchElementStateResponse {
613 pub state: ElementState,
614}
615
616impl fidl::Persistable for ReaderWatchElementStateResponse {}
617
618#[derive(Clone, Debug, PartialEq)]
619pub struct ReaderGetElementsResponse {
620 pub processing_elements: Vec<Element>,
621}
622
623impl fidl::Persistable for ReaderGetElementsResponse {}
624
625#[derive(Clone, Debug, PartialEq)]
626pub struct ReaderGetTopologiesResponse {
627 pub topologies: Vec<Topology>,
628}
629
630impl fidl::Persistable for ReaderGetTopologiesResponse {}
631
632#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
633#[repr(C)]
634pub struct ReaderWatchTopologyResponse {
635 pub topology_id: u64,
636}
637
638impl fidl::Persistable for ReaderWatchTopologyResponse {}
639
640#[derive(Clone, Debug, PartialEq)]
641pub struct SignalProcessingSetElementStateRequest {
642 pub processing_element_id: u64,
643 pub state: SettableElementState,
644}
645
646impl fidl::Persistable for SignalProcessingSetElementStateRequest {}
647
648#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
649#[repr(C)]
650pub struct SignalProcessingSetTopologyRequest {
651 pub topology_id: u64,
652}
653
654impl fidl::Persistable for SignalProcessingSetTopologyRequest {}
655
656#[derive(Clone, Debug, Default, PartialEq)]
658pub struct DaiInterconnect {
659 pub plug_detect_capabilities: Option<PlugDetectCapabilities>,
663 #[doc(hidden)]
664 pub __source_breaking: fidl::marker::SourceBreaking,
665}
666
667impl fidl::Persistable for DaiInterconnect {}
668
669#[derive(Clone, Debug, Default, PartialEq)]
671pub struct DaiInterconnectElementState {
672 pub plug_state: Option<PlugState>,
676 pub external_delay: Option<i64>,
687 #[doc(hidden)]
688 pub __source_breaking: fidl::marker::SourceBreaking,
689}
690
691impl fidl::Persistable for DaiInterconnectElementState {}
692
693#[derive(Clone, Debug, Default, PartialEq)]
695pub struct Dynamics {
696 pub bands: Option<Vec<DynamicsBand>>,
703 pub supported_controls: Option<DynamicsSupportedControls>,
708 #[doc(hidden)]
709 pub __source_breaking: fidl::marker::SourceBreaking,
710}
711
712impl fidl::Persistable for Dynamics {}
713
714#[derive(Clone, Debug, Default, PartialEq)]
716pub struct DynamicsBand {
717 pub id: Option<u64>,
723 #[doc(hidden)]
724 pub __source_breaking: fidl::marker::SourceBreaking,
725}
726
727impl fidl::Persistable for DynamicsBand {}
728
729#[derive(Clone, Debug, Default, PartialEq)]
733pub struct DynamicsBandState {
734 pub id: Option<u64>,
737 pub min_frequency: Option<u32>,
741 pub max_frequency: Option<u32>,
747 pub threshold_db: Option<f32>,
753 pub threshold_type: Option<ThresholdType>,
759 pub ratio: Option<f32>,
763 pub knee_width_db: Option<f32>,
772 pub attack: Option<i64>,
779 pub release: Option<i64>,
786 pub output_gain_db: Option<f32>,
793 pub input_gain_db: Option<f32>,
800 pub level_type: Option<LevelType>,
807 pub lookahead: Option<i64>,
814 pub linked_channels: Option<bool>,
823 #[doc(hidden)]
824 pub __source_breaking: fidl::marker::SourceBreaking,
825}
826
827impl fidl::Persistable for DynamicsBandState {}
828
829#[derive(Clone, Debug, Default, PartialEq)]
831pub struct DynamicsElementState {
832 pub band_states: Option<Vec<DynamicsBandState>>,
838 #[doc(hidden)]
839 pub __source_breaking: fidl::marker::SourceBreaking,
840}
841
842impl fidl::Persistable for DynamicsElementState {}
843
844#[derive(Clone, Debug, Default, PartialEq)]
845pub struct Element {
846 pub id: Option<u64>,
851 pub type_: Option<ElementType>,
855 pub type_specific: Option<TypeSpecificElement>,
861 pub can_disable: Option<bool>,
867 pub description: Option<String>,
871 pub can_stop: Option<bool>,
876 pub can_bypass: Option<bool>,
881 #[doc(hidden)]
882 pub __source_breaking: fidl::marker::SourceBreaking,
883}
884
885impl fidl::Persistable for Element {}
886
887#[derive(Clone, Debug, Default, PartialEq)]
890pub struct ElementState {
891 pub type_specific: Option<TypeSpecificElementState>,
901 pub enabled: Option<bool>,
907 pub latency: Option<Latency>,
913 pub vendor_specific_data: Option<Vec<u8>>,
918 pub started: Option<bool>,
929 pub bypassed: Option<bool>,
942 pub turn_on_delay: Option<i64>,
953 pub turn_off_delay: Option<i64>,
964 pub processing_delay: Option<i64>,
976 #[doc(hidden)]
977 pub __source_breaking: fidl::marker::SourceBreaking,
978}
979
980impl fidl::Persistable for ElementState {}
981
982#[derive(Clone, Debug, Default, PartialEq)]
988pub struct Endpoint {
989 pub type_: Option<EndpointType>,
993 pub plug_detect_capabilities: Option<PlugDetectCapabilities>,
996 #[doc(hidden)]
997 pub __source_breaking: fidl::marker::SourceBreaking,
998}
999
1000impl fidl::Persistable for Endpoint {}
1001
1002#[derive(Clone, Debug, Default, PartialEq)]
1008pub struct EndpointElementState {
1009 pub plug_state: Option<PlugState>,
1013 #[doc(hidden)]
1014 pub __source_breaking: fidl::marker::SourceBreaking,
1015}
1016
1017impl fidl::Persistable for EndpointElementState {}
1018
1019#[derive(Clone, Debug, Default, PartialEq)]
1021pub struct Equalizer {
1022 pub bands: Option<Vec<EqualizerBand>>,
1029 pub supported_controls: Option<EqualizerSupportedControls>,
1033 pub can_disable_bands: Option<bool>,
1040 pub min_frequency: Option<u32>,
1044 pub max_frequency: Option<u32>,
1048 pub max_q: Option<f32>,
1054 pub min_gain_db: Option<f32>,
1060 pub max_gain_db: Option<f32>,
1066 #[doc(hidden)]
1067 pub __source_breaking: fidl::marker::SourceBreaking,
1068}
1069
1070impl fidl::Persistable for Equalizer {}
1071
1072#[derive(Clone, Debug, Default, PartialEq)]
1074pub struct EqualizerBand {
1075 pub id: Option<u64>,
1080 #[doc(hidden)]
1081 pub __source_breaking: fidl::marker::SourceBreaking,
1082}
1083
1084impl fidl::Persistable for EqualizerBand {}
1085
1086#[derive(Clone, Debug, Default, PartialEq)]
1088pub struct EqualizerBandState {
1089 pub id: Option<u64>,
1093 pub type_: Option<EqualizerBandType>,
1099 pub frequency: Option<u32>,
1105 pub q: Option<f32>,
1113 pub gain_db: Option<f32>,
1118 pub enabled: Option<bool>,
1130 #[doc(hidden)]
1131 pub __source_breaking: fidl::marker::SourceBreaking,
1132}
1133
1134impl fidl::Persistable for EqualizerBandState {}
1135
1136#[derive(Clone, Debug, Default, PartialEq)]
1138pub struct EqualizerElementState {
1139 pub bands_state: Option<Vec<EqualizerBandState>>,
1145 pub band_states: Option<Vec<EqualizerBandState>>,
1154 #[doc(hidden)]
1155 pub __source_breaking: fidl::marker::SourceBreaking,
1156}
1157
1158impl fidl::Persistable for EqualizerElementState {}
1159
1160#[derive(Clone, Debug, Default, PartialEq)]
1162pub struct Gain {
1163 pub type_: Option<GainType>,
1167 pub domain: Option<GainDomain>,
1172 pub min_gain: Option<f32>,
1176 pub max_gain: Option<f32>,
1180 pub min_gain_step: Option<f32>,
1186 #[doc(hidden)]
1187 pub __source_breaking: fidl::marker::SourceBreaking,
1188}
1189
1190impl fidl::Persistable for Gain {}
1191
1192#[derive(Clone, Debug, Default, PartialEq)]
1194pub struct GainElementState {
1195 pub gain: Option<f32>,
1199 #[doc(hidden)]
1200 pub __source_breaking: fidl::marker::SourceBreaking,
1201}
1202
1203impl fidl::Persistable for GainElementState {}
1204
1205#[derive(Clone, Debug, Default, PartialEq)]
1210pub struct PlugState {
1211 pub plugged: Option<bool>,
1215 pub plug_state_time: Option<i64>,
1220 #[doc(hidden)]
1221 pub __source_breaking: fidl::marker::SourceBreaking,
1222}
1223
1224impl fidl::Persistable for PlugState {}
1225
1226#[derive(Clone, Debug, Default, PartialEq)]
1228pub struct SettableElementState {
1229 pub type_specific: Option<SettableTypeSpecificElementState>,
1240 pub vendor_specific_data: Option<Vec<u8>>,
1246 pub started: Option<bool>,
1256 pub bypassed: Option<bool>,
1267 #[doc(hidden)]
1268 pub __source_breaking: fidl::marker::SourceBreaking,
1269}
1270
1271impl fidl::Persistable for SettableElementState {}
1272
1273#[derive(Clone, Debug, Default, PartialEq)]
1275pub struct Topology {
1276 pub id: Option<u64>,
1281 pub processing_elements_edge_pairs: Option<Vec<EdgePair>>,
1304 #[doc(hidden)]
1305 pub __source_breaking: fidl::marker::SourceBreaking,
1306}
1307
1308impl fidl::Persistable for Topology {}
1309
1310#[derive(Clone, Debug, Default, PartialEq)]
1312pub struct VendorSpecific {
1313 #[doc(hidden)]
1314 pub __source_breaking: fidl::marker::SourceBreaking,
1315}
1316
1317impl fidl::Persistable for VendorSpecific {}
1318
1319#[derive(Clone, Debug, Default, PartialEq)]
1321pub struct VendorSpecificState {
1322 #[doc(hidden)]
1323 pub __source_breaking: fidl::marker::SourceBreaking,
1324}
1325
1326impl fidl::Persistable for VendorSpecificState {}
1327
1328#[derive(Clone, Debug)]
1333pub enum Latency {
1334 LatencyTime(i64),
1336 LatencyFrames(u32),
1338 #[doc(hidden)]
1339 __SourceBreaking { unknown_ordinal: u64 },
1340}
1341
1342#[macro_export]
1344macro_rules! LatencyUnknown {
1345 () => {
1346 _
1347 };
1348}
1349
1350impl PartialEq for Latency {
1352 fn eq(&self, other: &Self) -> bool {
1353 match (self, other) {
1354 (Self::LatencyTime(x), Self::LatencyTime(y)) => *x == *y,
1355 (Self::LatencyFrames(x), Self::LatencyFrames(y)) => *x == *y,
1356 _ => false,
1357 }
1358 }
1359}
1360
1361impl Latency {
1362 #[inline]
1363 pub fn ordinal(&self) -> u64 {
1364 match *self {
1365 Self::LatencyTime(_) => 1,
1366 Self::LatencyFrames(_) => 2,
1367 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1368 }
1369 }
1370
1371 #[inline]
1372 pub fn unknown_variant_for_testing() -> Self {
1373 Self::__SourceBreaking { unknown_ordinal: 0 }
1374 }
1375
1376 #[inline]
1377 pub fn is_unknown(&self) -> bool {
1378 match self {
1379 Self::__SourceBreaking { .. } => true,
1380 _ => false,
1381 }
1382 }
1383}
1384
1385impl fidl::Persistable for Latency {}
1386
1387#[derive(Clone, Debug)]
1392pub enum SettableTypeSpecificElementState {
1393 VendorSpecific(VendorSpecificState),
1394 Gain(GainElementState),
1395 Equalizer(EqualizerElementState),
1396 Dynamics(DynamicsElementState),
1397 #[doc(hidden)]
1398 __SourceBreaking {
1399 unknown_ordinal: u64,
1400 },
1401}
1402
1403#[macro_export]
1405macro_rules! SettableTypeSpecificElementStateUnknown {
1406 () => {
1407 _
1408 };
1409}
1410
1411impl PartialEq for SettableTypeSpecificElementState {
1413 fn eq(&self, other: &Self) -> bool {
1414 match (self, other) {
1415 (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1416 (Self::Gain(x), Self::Gain(y)) => *x == *y,
1417 (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1418 (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1419 _ => false,
1420 }
1421 }
1422}
1423
1424impl SettableTypeSpecificElementState {
1425 #[inline]
1426 pub fn ordinal(&self) -> u64 {
1427 match *self {
1428 Self::VendorSpecific(_) => 1,
1429 Self::Gain(_) => 2,
1430 Self::Equalizer(_) => 3,
1431 Self::Dynamics(_) => 4,
1432 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1433 }
1434 }
1435
1436 #[inline]
1437 pub fn unknown_variant_for_testing() -> Self {
1438 Self::__SourceBreaking { unknown_ordinal: 0 }
1439 }
1440
1441 #[inline]
1442 pub fn is_unknown(&self) -> bool {
1443 match self {
1444 Self::__SourceBreaking { .. } => true,
1445 _ => false,
1446 }
1447 }
1448}
1449
1450impl fidl::Persistable for SettableTypeSpecificElementState {}
1451
1452#[derive(Clone, Debug)]
1454pub enum TypeSpecificElement {
1455 VendorSpecific(VendorSpecific),
1456 Gain(Gain),
1457 Equalizer(Equalizer),
1458 Dynamics(Dynamics),
1459 Endpoint(Endpoint),
1460 DaiInterconnect(DaiInterconnect),
1461 #[doc(hidden)]
1462 __SourceBreaking {
1463 unknown_ordinal: u64,
1464 },
1465}
1466
1467#[macro_export]
1469macro_rules! TypeSpecificElementUnknown {
1470 () => {
1471 _
1472 };
1473}
1474
1475impl PartialEq for TypeSpecificElement {
1477 fn eq(&self, other: &Self) -> bool {
1478 match (self, other) {
1479 (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1480 (Self::Gain(x), Self::Gain(y)) => *x == *y,
1481 (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1482 (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1483 (Self::Endpoint(x), Self::Endpoint(y)) => *x == *y,
1484 (Self::DaiInterconnect(x), Self::DaiInterconnect(y)) => *x == *y,
1485 _ => false,
1486 }
1487 }
1488}
1489
1490impl TypeSpecificElement {
1491 #[inline]
1492 pub fn ordinal(&self) -> u64 {
1493 match *self {
1494 Self::VendorSpecific(_) => 1,
1495 Self::Gain(_) => 2,
1496 Self::Equalizer(_) => 3,
1497 Self::Dynamics(_) => 4,
1498 Self::Endpoint(_) => 5,
1499 Self::DaiInterconnect(_) => 6,
1500 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1501 }
1502 }
1503
1504 #[inline]
1505 pub fn unknown_variant_for_testing() -> Self {
1506 Self::__SourceBreaking { unknown_ordinal: 0 }
1507 }
1508
1509 #[inline]
1510 pub fn is_unknown(&self) -> bool {
1511 match self {
1512 Self::__SourceBreaking { .. } => true,
1513 _ => false,
1514 }
1515 }
1516}
1517
1518impl fidl::Persistable for TypeSpecificElement {}
1519
1520#[derive(Clone, Debug)]
1525pub enum TypeSpecificElementState {
1526 VendorSpecific(VendorSpecificState),
1527 Gain(GainElementState),
1528 Equalizer(EqualizerElementState),
1529 Dynamics(DynamicsElementState),
1530 Endpoint(EndpointElementState),
1531 DaiInterconnect(DaiInterconnectElementState),
1532 #[doc(hidden)]
1533 __SourceBreaking {
1534 unknown_ordinal: u64,
1535 },
1536}
1537
1538#[macro_export]
1540macro_rules! TypeSpecificElementStateUnknown {
1541 () => {
1542 _
1543 };
1544}
1545
1546impl PartialEq for TypeSpecificElementState {
1548 fn eq(&self, other: &Self) -> bool {
1549 match (self, other) {
1550 (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1551 (Self::Gain(x), Self::Gain(y)) => *x == *y,
1552 (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1553 (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1554 (Self::Endpoint(x), Self::Endpoint(y)) => *x == *y,
1555 (Self::DaiInterconnect(x), Self::DaiInterconnect(y)) => *x == *y,
1556 _ => false,
1557 }
1558 }
1559}
1560
1561impl TypeSpecificElementState {
1562 #[inline]
1563 pub fn ordinal(&self) -> u64 {
1564 match *self {
1565 Self::VendorSpecific(_) => 1,
1566 Self::Gain(_) => 2,
1567 Self::Equalizer(_) => 3,
1568 Self::Dynamics(_) => 4,
1569 Self::Endpoint(_) => 5,
1570 Self::DaiInterconnect(_) => 6,
1571 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1572 }
1573 }
1574
1575 #[inline]
1576 pub fn unknown_variant_for_testing() -> Self {
1577 Self::__SourceBreaking { unknown_ordinal: 0 }
1578 }
1579
1580 #[inline]
1581 pub fn is_unknown(&self) -> bool {
1582 match self {
1583 Self::__SourceBreaking { .. } => true,
1584 _ => false,
1585 }
1586 }
1587}
1588
1589impl fidl::Persistable for TypeSpecificElementState {}
1590
1591pub mod connector_ordinals {
1592 pub const SIGNAL_PROCESSING_CONNECT: u64 = 0xa81907ce6066295;
1593}
1594
1595pub mod reader_ordinals {
1596 pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1597 pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1598 pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1599 pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1600}
1601
1602pub mod signal_processing_ordinals {
1603 pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1604 pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1605 pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1606 pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1607 pub const SET_TOPOLOGY: u64 = 0x1d9a7f9b8fee790c;
1608 pub const SET_ELEMENT_STATE: u64 = 0x38c3b2d4bae698f4;
1609}
1610
1611mod internal {
1612 use super::*;
1613 unsafe impl fidl::encoding::TypeMarker for DynamicsSupportedControls {
1614 type Owned = Self;
1615
1616 #[inline(always)]
1617 fn inline_align(_context: fidl::encoding::Context) -> usize {
1618 8
1619 }
1620
1621 #[inline(always)]
1622 fn inline_size(_context: fidl::encoding::Context) -> usize {
1623 8
1624 }
1625 }
1626
1627 impl fidl::encoding::ValueTypeMarker for DynamicsSupportedControls {
1628 type Borrowed<'a> = Self;
1629 #[inline(always)]
1630 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1631 *value
1632 }
1633 }
1634
1635 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1636 for DynamicsSupportedControls
1637 {
1638 #[inline]
1639 unsafe fn encode(
1640 self,
1641 encoder: &mut fidl::encoding::Encoder<'_, D>,
1642 offset: usize,
1643 _depth: fidl::encoding::Depth,
1644 ) -> fidl::Result<()> {
1645 encoder.debug_check_bounds::<Self>(offset);
1646 encoder.write_num(self.bits(), offset);
1647 Ok(())
1648 }
1649 }
1650
1651 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1652 for DynamicsSupportedControls
1653 {
1654 #[inline(always)]
1655 fn new_empty() -> Self {
1656 Self::empty()
1657 }
1658
1659 #[inline]
1660 unsafe fn decode(
1661 &mut self,
1662 decoder: &mut fidl::encoding::Decoder<'_, D>,
1663 offset: usize,
1664 _depth: fidl::encoding::Depth,
1665 ) -> fidl::Result<()> {
1666 decoder.debug_check_bounds::<Self>(offset);
1667 let prim = decoder.read_num::<u64>(offset);
1668 *self = Self::from_bits_allow_unknown(prim);
1669 Ok(())
1670 }
1671 }
1672 unsafe impl fidl::encoding::TypeMarker for EqualizerSupportedControls {
1673 type Owned = Self;
1674
1675 #[inline(always)]
1676 fn inline_align(_context: fidl::encoding::Context) -> usize {
1677 8
1678 }
1679
1680 #[inline(always)]
1681 fn inline_size(_context: fidl::encoding::Context) -> usize {
1682 8
1683 }
1684 }
1685
1686 impl fidl::encoding::ValueTypeMarker for EqualizerSupportedControls {
1687 type Borrowed<'a> = Self;
1688 #[inline(always)]
1689 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1690 *value
1691 }
1692 }
1693
1694 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1695 for EqualizerSupportedControls
1696 {
1697 #[inline]
1698 unsafe fn encode(
1699 self,
1700 encoder: &mut fidl::encoding::Encoder<'_, D>,
1701 offset: usize,
1702 _depth: fidl::encoding::Depth,
1703 ) -> fidl::Result<()> {
1704 encoder.debug_check_bounds::<Self>(offset);
1705 encoder.write_num(self.bits(), offset);
1706 Ok(())
1707 }
1708 }
1709
1710 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1711 for EqualizerSupportedControls
1712 {
1713 #[inline(always)]
1714 fn new_empty() -> Self {
1715 Self::empty()
1716 }
1717
1718 #[inline]
1719 unsafe fn decode(
1720 &mut self,
1721 decoder: &mut fidl::encoding::Decoder<'_, D>,
1722 offset: usize,
1723 _depth: fidl::encoding::Depth,
1724 ) -> fidl::Result<()> {
1725 decoder.debug_check_bounds::<Self>(offset);
1726 let prim = decoder.read_num::<u64>(offset);
1727 *self = Self::from_bits_allow_unknown(prim);
1728 Ok(())
1729 }
1730 }
1731 unsafe impl fidl::encoding::TypeMarker for ElementType {
1732 type Owned = Self;
1733
1734 #[inline(always)]
1735 fn inline_align(_context: fidl::encoding::Context) -> usize {
1736 std::mem::align_of::<u32>()
1737 }
1738
1739 #[inline(always)]
1740 fn inline_size(_context: fidl::encoding::Context) -> usize {
1741 std::mem::size_of::<u32>()
1742 }
1743
1744 #[inline(always)]
1745 fn encode_is_copy() -> bool {
1746 false
1747 }
1748
1749 #[inline(always)]
1750 fn decode_is_copy() -> bool {
1751 false
1752 }
1753 }
1754
1755 impl fidl::encoding::ValueTypeMarker for ElementType {
1756 type Borrowed<'a> = Self;
1757 #[inline(always)]
1758 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1759 *value
1760 }
1761 }
1762
1763 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ElementType {
1764 #[inline]
1765 unsafe fn encode(
1766 self,
1767 encoder: &mut fidl::encoding::Encoder<'_, D>,
1768 offset: usize,
1769 _depth: fidl::encoding::Depth,
1770 ) -> fidl::Result<()> {
1771 encoder.debug_check_bounds::<Self>(offset);
1772 encoder.write_num(self.into_primitive(), offset);
1773 Ok(())
1774 }
1775 }
1776
1777 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementType {
1778 #[inline(always)]
1779 fn new_empty() -> Self {
1780 Self::unknown()
1781 }
1782
1783 #[inline]
1784 unsafe fn decode(
1785 &mut self,
1786 decoder: &mut fidl::encoding::Decoder<'_, D>,
1787 offset: usize,
1788 _depth: fidl::encoding::Depth,
1789 ) -> fidl::Result<()> {
1790 decoder.debug_check_bounds::<Self>(offset);
1791 let prim = decoder.read_num::<u32>(offset);
1792
1793 *self = Self::from_primitive_allow_unknown(prim);
1794 Ok(())
1795 }
1796 }
1797 unsafe impl fidl::encoding::TypeMarker for EndpointType {
1798 type Owned = Self;
1799
1800 #[inline(always)]
1801 fn inline_align(_context: fidl::encoding::Context) -> usize {
1802 std::mem::align_of::<u8>()
1803 }
1804
1805 #[inline(always)]
1806 fn inline_size(_context: fidl::encoding::Context) -> usize {
1807 std::mem::size_of::<u8>()
1808 }
1809
1810 #[inline(always)]
1811 fn encode_is_copy() -> bool {
1812 false
1813 }
1814
1815 #[inline(always)]
1816 fn decode_is_copy() -> bool {
1817 false
1818 }
1819 }
1820
1821 impl fidl::encoding::ValueTypeMarker for EndpointType {
1822 type Borrowed<'a> = Self;
1823 #[inline(always)]
1824 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1825 *value
1826 }
1827 }
1828
1829 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EndpointType {
1830 #[inline]
1831 unsafe fn encode(
1832 self,
1833 encoder: &mut fidl::encoding::Encoder<'_, D>,
1834 offset: usize,
1835 _depth: fidl::encoding::Depth,
1836 ) -> fidl::Result<()> {
1837 encoder.debug_check_bounds::<Self>(offset);
1838 encoder.write_num(self.into_primitive(), offset);
1839 Ok(())
1840 }
1841 }
1842
1843 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EndpointType {
1844 #[inline(always)]
1845 fn new_empty() -> Self {
1846 Self::unknown()
1847 }
1848
1849 #[inline]
1850 unsafe fn decode(
1851 &mut self,
1852 decoder: &mut fidl::encoding::Decoder<'_, D>,
1853 offset: usize,
1854 _depth: fidl::encoding::Depth,
1855 ) -> fidl::Result<()> {
1856 decoder.debug_check_bounds::<Self>(offset);
1857 let prim = decoder.read_num::<u8>(offset);
1858
1859 *self = Self::from_primitive_allow_unknown(prim);
1860 Ok(())
1861 }
1862 }
1863 unsafe impl fidl::encoding::TypeMarker for EqualizerBandType {
1864 type Owned = Self;
1865
1866 #[inline(always)]
1867 fn inline_align(_context: fidl::encoding::Context) -> usize {
1868 std::mem::align_of::<u64>()
1869 }
1870
1871 #[inline(always)]
1872 fn inline_size(_context: fidl::encoding::Context) -> usize {
1873 std::mem::size_of::<u64>()
1874 }
1875
1876 #[inline(always)]
1877 fn encode_is_copy() -> bool {
1878 false
1879 }
1880
1881 #[inline(always)]
1882 fn decode_is_copy() -> bool {
1883 false
1884 }
1885 }
1886
1887 impl fidl::encoding::ValueTypeMarker for EqualizerBandType {
1888 type Borrowed<'a> = Self;
1889 #[inline(always)]
1890 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1891 *value
1892 }
1893 }
1894
1895 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1896 for EqualizerBandType
1897 {
1898 #[inline]
1899 unsafe fn encode(
1900 self,
1901 encoder: &mut fidl::encoding::Encoder<'_, D>,
1902 offset: usize,
1903 _depth: fidl::encoding::Depth,
1904 ) -> fidl::Result<()> {
1905 encoder.debug_check_bounds::<Self>(offset);
1906 encoder.write_num(self.into_primitive(), offset);
1907 Ok(())
1908 }
1909 }
1910
1911 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBandType {
1912 #[inline(always)]
1913 fn new_empty() -> Self {
1914 Self::unknown()
1915 }
1916
1917 #[inline]
1918 unsafe fn decode(
1919 &mut self,
1920 decoder: &mut fidl::encoding::Decoder<'_, D>,
1921 offset: usize,
1922 _depth: fidl::encoding::Depth,
1923 ) -> fidl::Result<()> {
1924 decoder.debug_check_bounds::<Self>(offset);
1925 let prim = decoder.read_num::<u64>(offset);
1926
1927 *self = Self::from_primitive_allow_unknown(prim);
1928 Ok(())
1929 }
1930 }
1931 unsafe impl fidl::encoding::TypeMarker for GainDomain {
1932 type Owned = Self;
1933
1934 #[inline(always)]
1935 fn inline_align(_context: fidl::encoding::Context) -> usize {
1936 std::mem::align_of::<u8>()
1937 }
1938
1939 #[inline(always)]
1940 fn inline_size(_context: fidl::encoding::Context) -> usize {
1941 std::mem::size_of::<u8>()
1942 }
1943
1944 #[inline(always)]
1945 fn encode_is_copy() -> bool {
1946 false
1947 }
1948
1949 #[inline(always)]
1950 fn decode_is_copy() -> bool {
1951 false
1952 }
1953 }
1954
1955 impl fidl::encoding::ValueTypeMarker for GainDomain {
1956 type Borrowed<'a> = Self;
1957 #[inline(always)]
1958 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1959 *value
1960 }
1961 }
1962
1963 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GainDomain {
1964 #[inline]
1965 unsafe fn encode(
1966 self,
1967 encoder: &mut fidl::encoding::Encoder<'_, D>,
1968 offset: usize,
1969 _depth: fidl::encoding::Depth,
1970 ) -> fidl::Result<()> {
1971 encoder.debug_check_bounds::<Self>(offset);
1972 encoder.write_num(self.into_primitive(), offset);
1973 Ok(())
1974 }
1975 }
1976
1977 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainDomain {
1978 #[inline(always)]
1979 fn new_empty() -> Self {
1980 Self::unknown()
1981 }
1982
1983 #[inline]
1984 unsafe fn decode(
1985 &mut self,
1986 decoder: &mut fidl::encoding::Decoder<'_, D>,
1987 offset: usize,
1988 _depth: fidl::encoding::Depth,
1989 ) -> fidl::Result<()> {
1990 decoder.debug_check_bounds::<Self>(offset);
1991 let prim = decoder.read_num::<u8>(offset);
1992
1993 *self = Self::from_primitive_allow_unknown(prim);
1994 Ok(())
1995 }
1996 }
1997 unsafe impl fidl::encoding::TypeMarker for GainType {
1998 type Owned = Self;
1999
2000 #[inline(always)]
2001 fn inline_align(_context: fidl::encoding::Context) -> usize {
2002 std::mem::align_of::<u8>()
2003 }
2004
2005 #[inline(always)]
2006 fn inline_size(_context: fidl::encoding::Context) -> usize {
2007 std::mem::size_of::<u8>()
2008 }
2009
2010 #[inline(always)]
2011 fn encode_is_copy() -> bool {
2012 true
2013 }
2014
2015 #[inline(always)]
2016 fn decode_is_copy() -> bool {
2017 false
2018 }
2019 }
2020
2021 impl fidl::encoding::ValueTypeMarker for GainType {
2022 type Borrowed<'a> = Self;
2023 #[inline(always)]
2024 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2025 *value
2026 }
2027 }
2028
2029 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GainType {
2030 #[inline]
2031 unsafe fn encode(
2032 self,
2033 encoder: &mut fidl::encoding::Encoder<'_, D>,
2034 offset: usize,
2035 _depth: fidl::encoding::Depth,
2036 ) -> fidl::Result<()> {
2037 encoder.debug_check_bounds::<Self>(offset);
2038 encoder.write_num(self.into_primitive(), offset);
2039 Ok(())
2040 }
2041 }
2042
2043 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainType {
2044 #[inline(always)]
2045 fn new_empty() -> Self {
2046 Self::Decibels
2047 }
2048
2049 #[inline]
2050 unsafe fn decode(
2051 &mut self,
2052 decoder: &mut fidl::encoding::Decoder<'_, D>,
2053 offset: usize,
2054 _depth: fidl::encoding::Depth,
2055 ) -> fidl::Result<()> {
2056 decoder.debug_check_bounds::<Self>(offset);
2057 let prim = decoder.read_num::<u8>(offset);
2058
2059 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2060 Ok(())
2061 }
2062 }
2063 unsafe impl fidl::encoding::TypeMarker for LevelType {
2064 type Owned = Self;
2065
2066 #[inline(always)]
2067 fn inline_align(_context: fidl::encoding::Context) -> usize {
2068 std::mem::align_of::<u8>()
2069 }
2070
2071 #[inline(always)]
2072 fn inline_size(_context: fidl::encoding::Context) -> usize {
2073 std::mem::size_of::<u8>()
2074 }
2075
2076 #[inline(always)]
2077 fn encode_is_copy() -> bool {
2078 true
2079 }
2080
2081 #[inline(always)]
2082 fn decode_is_copy() -> bool {
2083 false
2084 }
2085 }
2086
2087 impl fidl::encoding::ValueTypeMarker for LevelType {
2088 type Borrowed<'a> = Self;
2089 #[inline(always)]
2090 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2091 *value
2092 }
2093 }
2094
2095 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LevelType {
2096 #[inline]
2097 unsafe fn encode(
2098 self,
2099 encoder: &mut fidl::encoding::Encoder<'_, D>,
2100 offset: usize,
2101 _depth: fidl::encoding::Depth,
2102 ) -> fidl::Result<()> {
2103 encoder.debug_check_bounds::<Self>(offset);
2104 encoder.write_num(self.into_primitive(), offset);
2105 Ok(())
2106 }
2107 }
2108
2109 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelType {
2110 #[inline(always)]
2111 fn new_empty() -> Self {
2112 Self::Peak
2113 }
2114
2115 #[inline]
2116 unsafe fn decode(
2117 &mut self,
2118 decoder: &mut fidl::encoding::Decoder<'_, D>,
2119 offset: usize,
2120 _depth: fidl::encoding::Depth,
2121 ) -> fidl::Result<()> {
2122 decoder.debug_check_bounds::<Self>(offset);
2123 let prim = decoder.read_num::<u8>(offset);
2124
2125 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2126 Ok(())
2127 }
2128 }
2129 unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2130 type Owned = Self;
2131
2132 #[inline(always)]
2133 fn inline_align(_context: fidl::encoding::Context) -> usize {
2134 std::mem::align_of::<u32>()
2135 }
2136
2137 #[inline(always)]
2138 fn inline_size(_context: fidl::encoding::Context) -> usize {
2139 std::mem::size_of::<u32>()
2140 }
2141
2142 #[inline(always)]
2143 fn encode_is_copy() -> bool {
2144 false
2145 }
2146
2147 #[inline(always)]
2148 fn decode_is_copy() -> bool {
2149 false
2150 }
2151 }
2152
2153 impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2154 type Borrowed<'a> = Self;
2155 #[inline(always)]
2156 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2157 *value
2158 }
2159 }
2160
2161 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2162 for PlugDetectCapabilities
2163 {
2164 #[inline]
2165 unsafe fn encode(
2166 self,
2167 encoder: &mut fidl::encoding::Encoder<'_, D>,
2168 offset: usize,
2169 _depth: fidl::encoding::Depth,
2170 ) -> fidl::Result<()> {
2171 encoder.debug_check_bounds::<Self>(offset);
2172 encoder.write_num(self.into_primitive(), offset);
2173 Ok(())
2174 }
2175 }
2176
2177 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2178 for PlugDetectCapabilities
2179 {
2180 #[inline(always)]
2181 fn new_empty() -> Self {
2182 Self::unknown()
2183 }
2184
2185 #[inline]
2186 unsafe fn decode(
2187 &mut self,
2188 decoder: &mut fidl::encoding::Decoder<'_, D>,
2189 offset: usize,
2190 _depth: fidl::encoding::Depth,
2191 ) -> fidl::Result<()> {
2192 decoder.debug_check_bounds::<Self>(offset);
2193 let prim = decoder.read_num::<u32>(offset);
2194
2195 *self = Self::from_primitive_allow_unknown(prim);
2196 Ok(())
2197 }
2198 }
2199 unsafe impl fidl::encoding::TypeMarker for ThresholdType {
2200 type Owned = Self;
2201
2202 #[inline(always)]
2203 fn inline_align(_context: fidl::encoding::Context) -> usize {
2204 std::mem::align_of::<u8>()
2205 }
2206
2207 #[inline(always)]
2208 fn inline_size(_context: fidl::encoding::Context) -> usize {
2209 std::mem::size_of::<u8>()
2210 }
2211
2212 #[inline(always)]
2213 fn encode_is_copy() -> bool {
2214 true
2215 }
2216
2217 #[inline(always)]
2218 fn decode_is_copy() -> bool {
2219 false
2220 }
2221 }
2222
2223 impl fidl::encoding::ValueTypeMarker for ThresholdType {
2224 type Borrowed<'a> = Self;
2225 #[inline(always)]
2226 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2227 *value
2228 }
2229 }
2230
2231 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ThresholdType {
2232 #[inline]
2233 unsafe fn encode(
2234 self,
2235 encoder: &mut fidl::encoding::Encoder<'_, D>,
2236 offset: usize,
2237 _depth: fidl::encoding::Depth,
2238 ) -> fidl::Result<()> {
2239 encoder.debug_check_bounds::<Self>(offset);
2240 encoder.write_num(self.into_primitive(), offset);
2241 Ok(())
2242 }
2243 }
2244
2245 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ThresholdType {
2246 #[inline(always)]
2247 fn new_empty() -> Self {
2248 Self::Above
2249 }
2250
2251 #[inline]
2252 unsafe fn decode(
2253 &mut self,
2254 decoder: &mut fidl::encoding::Decoder<'_, D>,
2255 offset: usize,
2256 _depth: fidl::encoding::Depth,
2257 ) -> fidl::Result<()> {
2258 decoder.debug_check_bounds::<Self>(offset);
2259 let prim = decoder.read_num::<u8>(offset);
2260
2261 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2262 Ok(())
2263 }
2264 }
2265
2266 impl fidl::encoding::ValueTypeMarker for EdgePair {
2267 type Borrowed<'a> = &'a Self;
2268 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2269 value
2270 }
2271 }
2272
2273 unsafe impl fidl::encoding::TypeMarker for EdgePair {
2274 type Owned = Self;
2275
2276 #[inline(always)]
2277 fn inline_align(_context: fidl::encoding::Context) -> usize {
2278 8
2279 }
2280
2281 #[inline(always)]
2282 fn inline_size(_context: fidl::encoding::Context) -> usize {
2283 16
2284 }
2285 #[inline(always)]
2286 fn encode_is_copy() -> bool {
2287 true
2288 }
2289
2290 #[inline(always)]
2291 fn decode_is_copy() -> bool {
2292 true
2293 }
2294 }
2295
2296 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EdgePair, D> for &EdgePair {
2297 #[inline]
2298 unsafe fn encode(
2299 self,
2300 encoder: &mut fidl::encoding::Encoder<'_, D>,
2301 offset: usize,
2302 _depth: fidl::encoding::Depth,
2303 ) -> fidl::Result<()> {
2304 encoder.debug_check_bounds::<EdgePair>(offset);
2305 unsafe {
2306 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2308 (buf_ptr as *mut EdgePair).write_unaligned((self as *const EdgePair).read());
2309 }
2312 Ok(())
2313 }
2314 }
2315 unsafe impl<
2316 D: fidl::encoding::ResourceDialect,
2317 T0: fidl::encoding::Encode<u64, D>,
2318 T1: fidl::encoding::Encode<u64, D>,
2319 > fidl::encoding::Encode<EdgePair, D> for (T0, T1)
2320 {
2321 #[inline]
2322 unsafe fn encode(
2323 self,
2324 encoder: &mut fidl::encoding::Encoder<'_, D>,
2325 offset: usize,
2326 depth: fidl::encoding::Depth,
2327 ) -> fidl::Result<()> {
2328 encoder.debug_check_bounds::<EdgePair>(offset);
2329 self.0.encode(encoder, offset + 0, depth)?;
2333 self.1.encode(encoder, offset + 8, depth)?;
2334 Ok(())
2335 }
2336 }
2337
2338 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EdgePair {
2339 #[inline(always)]
2340 fn new_empty() -> Self {
2341 Self {
2342 processing_element_id_from: fidl::new_empty!(u64, D),
2343 processing_element_id_to: fidl::new_empty!(u64, D),
2344 }
2345 }
2346
2347 #[inline]
2348 unsafe fn decode(
2349 &mut self,
2350 decoder: &mut fidl::encoding::Decoder<'_, D>,
2351 offset: usize,
2352 _depth: fidl::encoding::Depth,
2353 ) -> fidl::Result<()> {
2354 decoder.debug_check_bounds::<Self>(offset);
2355 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2356 unsafe {
2359 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2360 }
2361 Ok(())
2362 }
2363 }
2364
2365 impl fidl::encoding::ValueTypeMarker for ReaderWatchElementStateRequest {
2366 type Borrowed<'a> = &'a Self;
2367 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2368 value
2369 }
2370 }
2371
2372 unsafe impl fidl::encoding::TypeMarker for ReaderWatchElementStateRequest {
2373 type Owned = Self;
2374
2375 #[inline(always)]
2376 fn inline_align(_context: fidl::encoding::Context) -> usize {
2377 8
2378 }
2379
2380 #[inline(always)]
2381 fn inline_size(_context: fidl::encoding::Context) -> usize {
2382 8
2383 }
2384 #[inline(always)]
2385 fn encode_is_copy() -> bool {
2386 true
2387 }
2388
2389 #[inline(always)]
2390 fn decode_is_copy() -> bool {
2391 true
2392 }
2393 }
2394
2395 unsafe impl<D: fidl::encoding::ResourceDialect>
2396 fidl::encoding::Encode<ReaderWatchElementStateRequest, D>
2397 for &ReaderWatchElementStateRequest
2398 {
2399 #[inline]
2400 unsafe fn encode(
2401 self,
2402 encoder: &mut fidl::encoding::Encoder<'_, D>,
2403 offset: usize,
2404 _depth: fidl::encoding::Depth,
2405 ) -> fidl::Result<()> {
2406 encoder.debug_check_bounds::<ReaderWatchElementStateRequest>(offset);
2407 unsafe {
2408 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2410 (buf_ptr as *mut ReaderWatchElementStateRequest)
2411 .write_unaligned((self as *const ReaderWatchElementStateRequest).read());
2412 }
2415 Ok(())
2416 }
2417 }
2418 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2419 fidl::encoding::Encode<ReaderWatchElementStateRequest, D> for (T0,)
2420 {
2421 #[inline]
2422 unsafe fn encode(
2423 self,
2424 encoder: &mut fidl::encoding::Encoder<'_, D>,
2425 offset: usize,
2426 depth: fidl::encoding::Depth,
2427 ) -> fidl::Result<()> {
2428 encoder.debug_check_bounds::<ReaderWatchElementStateRequest>(offset);
2429 self.0.encode(encoder, offset + 0, depth)?;
2433 Ok(())
2434 }
2435 }
2436
2437 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2438 for ReaderWatchElementStateRequest
2439 {
2440 #[inline(always)]
2441 fn new_empty() -> Self {
2442 Self { processing_element_id: fidl::new_empty!(u64, D) }
2443 }
2444
2445 #[inline]
2446 unsafe fn decode(
2447 &mut self,
2448 decoder: &mut fidl::encoding::Decoder<'_, D>,
2449 offset: usize,
2450 _depth: fidl::encoding::Depth,
2451 ) -> fidl::Result<()> {
2452 decoder.debug_check_bounds::<Self>(offset);
2453 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2454 unsafe {
2457 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2458 }
2459 Ok(())
2460 }
2461 }
2462
2463 impl fidl::encoding::ValueTypeMarker for ReaderWatchElementStateResponse {
2464 type Borrowed<'a> = &'a Self;
2465 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2466 value
2467 }
2468 }
2469
2470 unsafe impl fidl::encoding::TypeMarker for ReaderWatchElementStateResponse {
2471 type Owned = Self;
2472
2473 #[inline(always)]
2474 fn inline_align(_context: fidl::encoding::Context) -> usize {
2475 8
2476 }
2477
2478 #[inline(always)]
2479 fn inline_size(_context: fidl::encoding::Context) -> usize {
2480 16
2481 }
2482 }
2483
2484 unsafe impl<D: fidl::encoding::ResourceDialect>
2485 fidl::encoding::Encode<ReaderWatchElementStateResponse, D>
2486 for &ReaderWatchElementStateResponse
2487 {
2488 #[inline]
2489 unsafe fn encode(
2490 self,
2491 encoder: &mut fidl::encoding::Encoder<'_, D>,
2492 offset: usize,
2493 _depth: fidl::encoding::Depth,
2494 ) -> fidl::Result<()> {
2495 encoder.debug_check_bounds::<ReaderWatchElementStateResponse>(offset);
2496 fidl::encoding::Encode::<ReaderWatchElementStateResponse, D>::encode(
2498 (<ElementState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
2499 encoder,
2500 offset,
2501 _depth,
2502 )
2503 }
2504 }
2505 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ElementState, D>>
2506 fidl::encoding::Encode<ReaderWatchElementStateResponse, D> for (T0,)
2507 {
2508 #[inline]
2509 unsafe fn encode(
2510 self,
2511 encoder: &mut fidl::encoding::Encoder<'_, D>,
2512 offset: usize,
2513 depth: fidl::encoding::Depth,
2514 ) -> fidl::Result<()> {
2515 encoder.debug_check_bounds::<ReaderWatchElementStateResponse>(offset);
2516 self.0.encode(encoder, offset + 0, depth)?;
2520 Ok(())
2521 }
2522 }
2523
2524 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2525 for ReaderWatchElementStateResponse
2526 {
2527 #[inline(always)]
2528 fn new_empty() -> Self {
2529 Self { state: fidl::new_empty!(ElementState, D) }
2530 }
2531
2532 #[inline]
2533 unsafe fn decode(
2534 &mut self,
2535 decoder: &mut fidl::encoding::Decoder<'_, D>,
2536 offset: usize,
2537 _depth: fidl::encoding::Depth,
2538 ) -> fidl::Result<()> {
2539 decoder.debug_check_bounds::<Self>(offset);
2540 fidl::decode!(ElementState, D, &mut self.state, decoder, offset + 0, _depth)?;
2542 Ok(())
2543 }
2544 }
2545
2546 impl fidl::encoding::ValueTypeMarker for ReaderGetElementsResponse {
2547 type Borrowed<'a> = &'a Self;
2548 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2549 value
2550 }
2551 }
2552
2553 unsafe impl fidl::encoding::TypeMarker for ReaderGetElementsResponse {
2554 type Owned = Self;
2555
2556 #[inline(always)]
2557 fn inline_align(_context: fidl::encoding::Context) -> usize {
2558 8
2559 }
2560
2561 #[inline(always)]
2562 fn inline_size(_context: fidl::encoding::Context) -> usize {
2563 16
2564 }
2565 }
2566
2567 unsafe impl<D: fidl::encoding::ResourceDialect>
2568 fidl::encoding::Encode<ReaderGetElementsResponse, D> for &ReaderGetElementsResponse
2569 {
2570 #[inline]
2571 unsafe fn encode(
2572 self,
2573 encoder: &mut fidl::encoding::Encoder<'_, D>,
2574 offset: usize,
2575 _depth: fidl::encoding::Depth,
2576 ) -> fidl::Result<()> {
2577 encoder.debug_check_bounds::<ReaderGetElementsResponse>(offset);
2578 fidl::encoding::Encode::<ReaderGetElementsResponse, D>::encode(
2580 (<fidl::encoding::Vector<Element, 64> as fidl::encoding::ValueTypeMarker>::borrow(
2581 &self.processing_elements,
2582 ),),
2583 encoder,
2584 offset,
2585 _depth,
2586 )
2587 }
2588 }
2589 unsafe impl<
2590 D: fidl::encoding::ResourceDialect,
2591 T0: fidl::encoding::Encode<fidl::encoding::Vector<Element, 64>, D>,
2592 > fidl::encoding::Encode<ReaderGetElementsResponse, D> for (T0,)
2593 {
2594 #[inline]
2595 unsafe fn encode(
2596 self,
2597 encoder: &mut fidl::encoding::Encoder<'_, D>,
2598 offset: usize,
2599 depth: fidl::encoding::Depth,
2600 ) -> fidl::Result<()> {
2601 encoder.debug_check_bounds::<ReaderGetElementsResponse>(offset);
2602 self.0.encode(encoder, offset + 0, depth)?;
2606 Ok(())
2607 }
2608 }
2609
2610 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2611 for ReaderGetElementsResponse
2612 {
2613 #[inline(always)]
2614 fn new_empty() -> Self {
2615 Self { processing_elements: fidl::new_empty!(fidl::encoding::Vector<Element, 64>, D) }
2616 }
2617
2618 #[inline]
2619 unsafe fn decode(
2620 &mut self,
2621 decoder: &mut fidl::encoding::Decoder<'_, D>,
2622 offset: usize,
2623 _depth: fidl::encoding::Depth,
2624 ) -> fidl::Result<()> {
2625 decoder.debug_check_bounds::<Self>(offset);
2626 fidl::decode!(fidl::encoding::Vector<Element, 64>, D, &mut self.processing_elements, decoder, offset + 0, _depth)?;
2628 Ok(())
2629 }
2630 }
2631
2632 impl fidl::encoding::ValueTypeMarker for ReaderGetTopologiesResponse {
2633 type Borrowed<'a> = &'a Self;
2634 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2635 value
2636 }
2637 }
2638
2639 unsafe impl fidl::encoding::TypeMarker for ReaderGetTopologiesResponse {
2640 type Owned = Self;
2641
2642 #[inline(always)]
2643 fn inline_align(_context: fidl::encoding::Context) -> usize {
2644 8
2645 }
2646
2647 #[inline(always)]
2648 fn inline_size(_context: fidl::encoding::Context) -> usize {
2649 16
2650 }
2651 }
2652
2653 unsafe impl<D: fidl::encoding::ResourceDialect>
2654 fidl::encoding::Encode<ReaderGetTopologiesResponse, D> for &ReaderGetTopologiesResponse
2655 {
2656 #[inline]
2657 unsafe fn encode(
2658 self,
2659 encoder: &mut fidl::encoding::Encoder<'_, D>,
2660 offset: usize,
2661 _depth: fidl::encoding::Depth,
2662 ) -> fidl::Result<()> {
2663 encoder.debug_check_bounds::<ReaderGetTopologiesResponse>(offset);
2664 fidl::encoding::Encode::<ReaderGetTopologiesResponse, D>::encode(
2666 (
2667 <fidl::encoding::Vector<Topology, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.topologies),
2668 ),
2669 encoder, offset, _depth
2670 )
2671 }
2672 }
2673 unsafe impl<
2674 D: fidl::encoding::ResourceDialect,
2675 T0: fidl::encoding::Encode<fidl::encoding::Vector<Topology, 64>, D>,
2676 > fidl::encoding::Encode<ReaderGetTopologiesResponse, D> for (T0,)
2677 {
2678 #[inline]
2679 unsafe fn encode(
2680 self,
2681 encoder: &mut fidl::encoding::Encoder<'_, D>,
2682 offset: usize,
2683 depth: fidl::encoding::Depth,
2684 ) -> fidl::Result<()> {
2685 encoder.debug_check_bounds::<ReaderGetTopologiesResponse>(offset);
2686 self.0.encode(encoder, offset + 0, depth)?;
2690 Ok(())
2691 }
2692 }
2693
2694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2695 for ReaderGetTopologiesResponse
2696 {
2697 #[inline(always)]
2698 fn new_empty() -> Self {
2699 Self { topologies: fidl::new_empty!(fidl::encoding::Vector<Topology, 64>, D) }
2700 }
2701
2702 #[inline]
2703 unsafe fn decode(
2704 &mut self,
2705 decoder: &mut fidl::encoding::Decoder<'_, D>,
2706 offset: usize,
2707 _depth: fidl::encoding::Depth,
2708 ) -> fidl::Result<()> {
2709 decoder.debug_check_bounds::<Self>(offset);
2710 fidl::decode!(fidl::encoding::Vector<Topology, 64>, D, &mut self.topologies, decoder, offset + 0, _depth)?;
2712 Ok(())
2713 }
2714 }
2715
2716 impl fidl::encoding::ValueTypeMarker for ReaderWatchTopologyResponse {
2717 type Borrowed<'a> = &'a Self;
2718 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2719 value
2720 }
2721 }
2722
2723 unsafe impl fidl::encoding::TypeMarker for ReaderWatchTopologyResponse {
2724 type Owned = Self;
2725
2726 #[inline(always)]
2727 fn inline_align(_context: fidl::encoding::Context) -> usize {
2728 8
2729 }
2730
2731 #[inline(always)]
2732 fn inline_size(_context: fidl::encoding::Context) -> usize {
2733 8
2734 }
2735 #[inline(always)]
2736 fn encode_is_copy() -> bool {
2737 true
2738 }
2739
2740 #[inline(always)]
2741 fn decode_is_copy() -> bool {
2742 true
2743 }
2744 }
2745
2746 unsafe impl<D: fidl::encoding::ResourceDialect>
2747 fidl::encoding::Encode<ReaderWatchTopologyResponse, D> for &ReaderWatchTopologyResponse
2748 {
2749 #[inline]
2750 unsafe fn encode(
2751 self,
2752 encoder: &mut fidl::encoding::Encoder<'_, D>,
2753 offset: usize,
2754 _depth: fidl::encoding::Depth,
2755 ) -> fidl::Result<()> {
2756 encoder.debug_check_bounds::<ReaderWatchTopologyResponse>(offset);
2757 unsafe {
2758 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2760 (buf_ptr as *mut ReaderWatchTopologyResponse)
2761 .write_unaligned((self as *const ReaderWatchTopologyResponse).read());
2762 }
2765 Ok(())
2766 }
2767 }
2768 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2769 fidl::encoding::Encode<ReaderWatchTopologyResponse, D> for (T0,)
2770 {
2771 #[inline]
2772 unsafe fn encode(
2773 self,
2774 encoder: &mut fidl::encoding::Encoder<'_, D>,
2775 offset: usize,
2776 depth: fidl::encoding::Depth,
2777 ) -> fidl::Result<()> {
2778 encoder.debug_check_bounds::<ReaderWatchTopologyResponse>(offset);
2779 self.0.encode(encoder, offset + 0, depth)?;
2783 Ok(())
2784 }
2785 }
2786
2787 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2788 for ReaderWatchTopologyResponse
2789 {
2790 #[inline(always)]
2791 fn new_empty() -> Self {
2792 Self { topology_id: fidl::new_empty!(u64, D) }
2793 }
2794
2795 #[inline]
2796 unsafe fn decode(
2797 &mut self,
2798 decoder: &mut fidl::encoding::Decoder<'_, D>,
2799 offset: usize,
2800 _depth: fidl::encoding::Depth,
2801 ) -> fidl::Result<()> {
2802 decoder.debug_check_bounds::<Self>(offset);
2803 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2804 unsafe {
2807 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2808 }
2809 Ok(())
2810 }
2811 }
2812
2813 impl fidl::encoding::ValueTypeMarker for SignalProcessingSetElementStateRequest {
2814 type Borrowed<'a> = &'a Self;
2815 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2816 value
2817 }
2818 }
2819
2820 unsafe impl fidl::encoding::TypeMarker for SignalProcessingSetElementStateRequest {
2821 type Owned = Self;
2822
2823 #[inline(always)]
2824 fn inline_align(_context: fidl::encoding::Context) -> usize {
2825 8
2826 }
2827
2828 #[inline(always)]
2829 fn inline_size(_context: fidl::encoding::Context) -> usize {
2830 24
2831 }
2832 }
2833
2834 unsafe impl<D: fidl::encoding::ResourceDialect>
2835 fidl::encoding::Encode<SignalProcessingSetElementStateRequest, D>
2836 for &SignalProcessingSetElementStateRequest
2837 {
2838 #[inline]
2839 unsafe fn encode(
2840 self,
2841 encoder: &mut fidl::encoding::Encoder<'_, D>,
2842 offset: usize,
2843 _depth: fidl::encoding::Depth,
2844 ) -> fidl::Result<()> {
2845 encoder.debug_check_bounds::<SignalProcessingSetElementStateRequest>(offset);
2846 fidl::encoding::Encode::<SignalProcessingSetElementStateRequest, D>::encode(
2848 (
2849 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.processing_element_id),
2850 <SettableElementState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
2851 ),
2852 encoder,
2853 offset,
2854 _depth,
2855 )
2856 }
2857 }
2858 unsafe impl<
2859 D: fidl::encoding::ResourceDialect,
2860 T0: fidl::encoding::Encode<u64, D>,
2861 T1: fidl::encoding::Encode<SettableElementState, D>,
2862 > fidl::encoding::Encode<SignalProcessingSetElementStateRequest, D> for (T0, T1)
2863 {
2864 #[inline]
2865 unsafe fn encode(
2866 self,
2867 encoder: &mut fidl::encoding::Encoder<'_, D>,
2868 offset: usize,
2869 depth: fidl::encoding::Depth,
2870 ) -> fidl::Result<()> {
2871 encoder.debug_check_bounds::<SignalProcessingSetElementStateRequest>(offset);
2872 self.0.encode(encoder, offset + 0, depth)?;
2876 self.1.encode(encoder, offset + 8, depth)?;
2877 Ok(())
2878 }
2879 }
2880
2881 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2882 for SignalProcessingSetElementStateRequest
2883 {
2884 #[inline(always)]
2885 fn new_empty() -> Self {
2886 Self {
2887 processing_element_id: fidl::new_empty!(u64, D),
2888 state: fidl::new_empty!(SettableElementState, D),
2889 }
2890 }
2891
2892 #[inline]
2893 unsafe fn decode(
2894 &mut self,
2895 decoder: &mut fidl::encoding::Decoder<'_, D>,
2896 offset: usize,
2897 _depth: fidl::encoding::Depth,
2898 ) -> fidl::Result<()> {
2899 decoder.debug_check_bounds::<Self>(offset);
2900 fidl::decode!(u64, D, &mut self.processing_element_id, decoder, offset + 0, _depth)?;
2902 fidl::decode!(SettableElementState, D, &mut self.state, decoder, offset + 8, _depth)?;
2903 Ok(())
2904 }
2905 }
2906
2907 impl fidl::encoding::ValueTypeMarker for SignalProcessingSetTopologyRequest {
2908 type Borrowed<'a> = &'a Self;
2909 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2910 value
2911 }
2912 }
2913
2914 unsafe impl fidl::encoding::TypeMarker for SignalProcessingSetTopologyRequest {
2915 type Owned = Self;
2916
2917 #[inline(always)]
2918 fn inline_align(_context: fidl::encoding::Context) -> usize {
2919 8
2920 }
2921
2922 #[inline(always)]
2923 fn inline_size(_context: fidl::encoding::Context) -> usize {
2924 8
2925 }
2926 #[inline(always)]
2927 fn encode_is_copy() -> bool {
2928 true
2929 }
2930
2931 #[inline(always)]
2932 fn decode_is_copy() -> bool {
2933 true
2934 }
2935 }
2936
2937 unsafe impl<D: fidl::encoding::ResourceDialect>
2938 fidl::encoding::Encode<SignalProcessingSetTopologyRequest, D>
2939 for &SignalProcessingSetTopologyRequest
2940 {
2941 #[inline]
2942 unsafe fn encode(
2943 self,
2944 encoder: &mut fidl::encoding::Encoder<'_, D>,
2945 offset: usize,
2946 _depth: fidl::encoding::Depth,
2947 ) -> fidl::Result<()> {
2948 encoder.debug_check_bounds::<SignalProcessingSetTopologyRequest>(offset);
2949 unsafe {
2950 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2952 (buf_ptr as *mut SignalProcessingSetTopologyRequest)
2953 .write_unaligned((self as *const SignalProcessingSetTopologyRequest).read());
2954 }
2957 Ok(())
2958 }
2959 }
2960 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2961 fidl::encoding::Encode<SignalProcessingSetTopologyRequest, D> for (T0,)
2962 {
2963 #[inline]
2964 unsafe fn encode(
2965 self,
2966 encoder: &mut fidl::encoding::Encoder<'_, D>,
2967 offset: usize,
2968 depth: fidl::encoding::Depth,
2969 ) -> fidl::Result<()> {
2970 encoder.debug_check_bounds::<SignalProcessingSetTopologyRequest>(offset);
2971 self.0.encode(encoder, offset + 0, depth)?;
2975 Ok(())
2976 }
2977 }
2978
2979 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2980 for SignalProcessingSetTopologyRequest
2981 {
2982 #[inline(always)]
2983 fn new_empty() -> Self {
2984 Self { topology_id: fidl::new_empty!(u64, D) }
2985 }
2986
2987 #[inline]
2988 unsafe fn decode(
2989 &mut self,
2990 decoder: &mut fidl::encoding::Decoder<'_, D>,
2991 offset: usize,
2992 _depth: fidl::encoding::Depth,
2993 ) -> fidl::Result<()> {
2994 decoder.debug_check_bounds::<Self>(offset);
2995 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2996 unsafe {
2999 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3000 }
3001 Ok(())
3002 }
3003 }
3004
3005 impl DaiInterconnect {
3006 #[inline(always)]
3007 fn max_ordinal_present(&self) -> u64 {
3008 if let Some(_) = self.plug_detect_capabilities {
3009 return 1;
3010 }
3011 0
3012 }
3013 }
3014
3015 impl fidl::encoding::ValueTypeMarker for DaiInterconnect {
3016 type Borrowed<'a> = &'a Self;
3017 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3018 value
3019 }
3020 }
3021
3022 unsafe impl fidl::encoding::TypeMarker for DaiInterconnect {
3023 type Owned = Self;
3024
3025 #[inline(always)]
3026 fn inline_align(_context: fidl::encoding::Context) -> usize {
3027 8
3028 }
3029
3030 #[inline(always)]
3031 fn inline_size(_context: fidl::encoding::Context) -> usize {
3032 16
3033 }
3034 }
3035
3036 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DaiInterconnect, D>
3037 for &DaiInterconnect
3038 {
3039 unsafe fn encode(
3040 self,
3041 encoder: &mut fidl::encoding::Encoder<'_, D>,
3042 offset: usize,
3043 mut depth: fidl::encoding::Depth,
3044 ) -> fidl::Result<()> {
3045 encoder.debug_check_bounds::<DaiInterconnect>(offset);
3046 let max_ordinal: u64 = self.max_ordinal_present();
3048 encoder.write_num(max_ordinal, offset);
3049 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3050 if max_ordinal == 0 {
3052 return Ok(());
3053 }
3054 depth.increment()?;
3055 let envelope_size = 8;
3056 let bytes_len = max_ordinal as usize * envelope_size;
3057 #[allow(unused_variables)]
3058 let offset = encoder.out_of_line_offset(bytes_len);
3059 let mut _prev_end_offset: usize = 0;
3060 if 1 > max_ordinal {
3061 return Ok(());
3062 }
3063
3064 let cur_offset: usize = (1 - 1) * envelope_size;
3067
3068 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3070
3071 fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
3076 self.plug_detect_capabilities
3077 .as_ref()
3078 .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3079 encoder,
3080 offset + cur_offset,
3081 depth,
3082 )?;
3083
3084 _prev_end_offset = cur_offset + envelope_size;
3085
3086 Ok(())
3087 }
3088 }
3089
3090 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DaiInterconnect {
3091 #[inline(always)]
3092 fn new_empty() -> Self {
3093 Self::default()
3094 }
3095
3096 unsafe fn decode(
3097 &mut self,
3098 decoder: &mut fidl::encoding::Decoder<'_, D>,
3099 offset: usize,
3100 mut depth: fidl::encoding::Depth,
3101 ) -> fidl::Result<()> {
3102 decoder.debug_check_bounds::<Self>(offset);
3103 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3104 None => return Err(fidl::Error::NotNullable),
3105 Some(len) => len,
3106 };
3107 if len == 0 {
3109 return Ok(());
3110 };
3111 depth.increment()?;
3112 let envelope_size = 8;
3113 let bytes_len = len * envelope_size;
3114 let offset = decoder.out_of_line_offset(bytes_len)?;
3115 let mut _next_ordinal_to_read = 0;
3117 let mut next_offset = offset;
3118 let end_offset = offset + bytes_len;
3119 _next_ordinal_to_read += 1;
3120 if next_offset >= end_offset {
3121 return Ok(());
3122 }
3123
3124 while _next_ordinal_to_read < 1 {
3126 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3127 _next_ordinal_to_read += 1;
3128 next_offset += envelope_size;
3129 }
3130
3131 let next_out_of_line = decoder.next_out_of_line();
3132 let handles_before = decoder.remaining_handles();
3133 if let Some((inlined, num_bytes, num_handles)) =
3134 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3135 {
3136 let member_inline_size =
3137 <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
3138 decoder.context,
3139 );
3140 if inlined != (member_inline_size <= 4) {
3141 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3142 }
3143 let inner_offset;
3144 let mut inner_depth = depth.clone();
3145 if inlined {
3146 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3147 inner_offset = next_offset;
3148 } else {
3149 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3150 inner_depth.increment()?;
3151 }
3152 let val_ref = self
3153 .plug_detect_capabilities
3154 .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
3155 fidl::decode!(
3156 PlugDetectCapabilities,
3157 D,
3158 val_ref,
3159 decoder,
3160 inner_offset,
3161 inner_depth
3162 )?;
3163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3164 {
3165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3166 }
3167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3169 }
3170 }
3171
3172 next_offset += envelope_size;
3173
3174 while next_offset < end_offset {
3176 _next_ordinal_to_read += 1;
3177 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3178 next_offset += envelope_size;
3179 }
3180
3181 Ok(())
3182 }
3183 }
3184
3185 impl DaiInterconnectElementState {
3186 #[inline(always)]
3187 fn max_ordinal_present(&self) -> u64 {
3188 if let Some(_) = self.external_delay {
3189 return 2;
3190 }
3191 if let Some(_) = self.plug_state {
3192 return 1;
3193 }
3194 0
3195 }
3196 }
3197
3198 impl fidl::encoding::ValueTypeMarker for DaiInterconnectElementState {
3199 type Borrowed<'a> = &'a Self;
3200 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3201 value
3202 }
3203 }
3204
3205 unsafe impl fidl::encoding::TypeMarker for DaiInterconnectElementState {
3206 type Owned = Self;
3207
3208 #[inline(always)]
3209 fn inline_align(_context: fidl::encoding::Context) -> usize {
3210 8
3211 }
3212
3213 #[inline(always)]
3214 fn inline_size(_context: fidl::encoding::Context) -> usize {
3215 16
3216 }
3217 }
3218
3219 unsafe impl<D: fidl::encoding::ResourceDialect>
3220 fidl::encoding::Encode<DaiInterconnectElementState, D> for &DaiInterconnectElementState
3221 {
3222 unsafe fn encode(
3223 self,
3224 encoder: &mut fidl::encoding::Encoder<'_, D>,
3225 offset: usize,
3226 mut depth: fidl::encoding::Depth,
3227 ) -> fidl::Result<()> {
3228 encoder.debug_check_bounds::<DaiInterconnectElementState>(offset);
3229 let max_ordinal: u64 = self.max_ordinal_present();
3231 encoder.write_num(max_ordinal, offset);
3232 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3233 if max_ordinal == 0 {
3235 return Ok(());
3236 }
3237 depth.increment()?;
3238 let envelope_size = 8;
3239 let bytes_len = max_ordinal as usize * envelope_size;
3240 #[allow(unused_variables)]
3241 let offset = encoder.out_of_line_offset(bytes_len);
3242 let mut _prev_end_offset: usize = 0;
3243 if 1 > max_ordinal {
3244 return Ok(());
3245 }
3246
3247 let cur_offset: usize = (1 - 1) * envelope_size;
3250
3251 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3253
3254 fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
3259 self.plug_state
3260 .as_ref()
3261 .map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
3262 encoder,
3263 offset + cur_offset,
3264 depth,
3265 )?;
3266
3267 _prev_end_offset = cur_offset + envelope_size;
3268 if 2 > max_ordinal {
3269 return Ok(());
3270 }
3271
3272 let cur_offset: usize = (2 - 1) * envelope_size;
3275
3276 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3278
3279 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3284 self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3285 encoder,
3286 offset + cur_offset,
3287 depth,
3288 )?;
3289
3290 _prev_end_offset = cur_offset + envelope_size;
3291
3292 Ok(())
3293 }
3294 }
3295
3296 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3297 for DaiInterconnectElementState
3298 {
3299 #[inline(always)]
3300 fn new_empty() -> Self {
3301 Self::default()
3302 }
3303
3304 unsafe fn decode(
3305 &mut self,
3306 decoder: &mut fidl::encoding::Decoder<'_, D>,
3307 offset: usize,
3308 mut depth: fidl::encoding::Depth,
3309 ) -> fidl::Result<()> {
3310 decoder.debug_check_bounds::<Self>(offset);
3311 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3312 None => return Err(fidl::Error::NotNullable),
3313 Some(len) => len,
3314 };
3315 if len == 0 {
3317 return Ok(());
3318 };
3319 depth.increment()?;
3320 let envelope_size = 8;
3321 let bytes_len = len * envelope_size;
3322 let offset = decoder.out_of_line_offset(bytes_len)?;
3323 let mut _next_ordinal_to_read = 0;
3325 let mut next_offset = offset;
3326 let end_offset = offset + bytes_len;
3327 _next_ordinal_to_read += 1;
3328 if next_offset >= end_offset {
3329 return Ok(());
3330 }
3331
3332 while _next_ordinal_to_read < 1 {
3334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3335 _next_ordinal_to_read += 1;
3336 next_offset += envelope_size;
3337 }
3338
3339 let next_out_of_line = decoder.next_out_of_line();
3340 let handles_before = decoder.remaining_handles();
3341 if let Some((inlined, num_bytes, num_handles)) =
3342 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3343 {
3344 let member_inline_size =
3345 <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3346 if inlined != (member_inline_size <= 4) {
3347 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3348 }
3349 let inner_offset;
3350 let mut inner_depth = depth.clone();
3351 if inlined {
3352 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3353 inner_offset = next_offset;
3354 } else {
3355 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3356 inner_depth.increment()?;
3357 }
3358 let val_ref = self.plug_state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
3359 fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
3360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3361 {
3362 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3363 }
3364 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3365 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3366 }
3367 }
3368
3369 next_offset += envelope_size;
3370 _next_ordinal_to_read += 1;
3371 if next_offset >= end_offset {
3372 return Ok(());
3373 }
3374
3375 while _next_ordinal_to_read < 2 {
3377 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3378 _next_ordinal_to_read += 1;
3379 next_offset += envelope_size;
3380 }
3381
3382 let next_out_of_line = decoder.next_out_of_line();
3383 let handles_before = decoder.remaining_handles();
3384 if let Some((inlined, num_bytes, num_handles)) =
3385 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3386 {
3387 let member_inline_size =
3388 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3389 if inlined != (member_inline_size <= 4) {
3390 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3391 }
3392 let inner_offset;
3393 let mut inner_depth = depth.clone();
3394 if inlined {
3395 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3396 inner_offset = next_offset;
3397 } else {
3398 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3399 inner_depth.increment()?;
3400 }
3401 let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
3402 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3403 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3404 {
3405 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3406 }
3407 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3408 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3409 }
3410 }
3411
3412 next_offset += envelope_size;
3413
3414 while next_offset < end_offset {
3416 _next_ordinal_to_read += 1;
3417 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3418 next_offset += envelope_size;
3419 }
3420
3421 Ok(())
3422 }
3423 }
3424
3425 impl Dynamics {
3426 #[inline(always)]
3427 fn max_ordinal_present(&self) -> u64 {
3428 if let Some(_) = self.supported_controls {
3429 return 2;
3430 }
3431 if let Some(_) = self.bands {
3432 return 1;
3433 }
3434 0
3435 }
3436 }
3437
3438 impl fidl::encoding::ValueTypeMarker for Dynamics {
3439 type Borrowed<'a> = &'a Self;
3440 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3441 value
3442 }
3443 }
3444
3445 unsafe impl fidl::encoding::TypeMarker for Dynamics {
3446 type Owned = Self;
3447
3448 #[inline(always)]
3449 fn inline_align(_context: fidl::encoding::Context) -> usize {
3450 8
3451 }
3452
3453 #[inline(always)]
3454 fn inline_size(_context: fidl::encoding::Context) -> usize {
3455 16
3456 }
3457 }
3458
3459 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dynamics, D> for &Dynamics {
3460 unsafe fn encode(
3461 self,
3462 encoder: &mut fidl::encoding::Encoder<'_, D>,
3463 offset: usize,
3464 mut depth: fidl::encoding::Depth,
3465 ) -> fidl::Result<()> {
3466 encoder.debug_check_bounds::<Dynamics>(offset);
3467 let max_ordinal: u64 = self.max_ordinal_present();
3469 encoder.write_num(max_ordinal, offset);
3470 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3471 if max_ordinal == 0 {
3473 return Ok(());
3474 }
3475 depth.increment()?;
3476 let envelope_size = 8;
3477 let bytes_len = max_ordinal as usize * envelope_size;
3478 #[allow(unused_variables)]
3479 let offset = encoder.out_of_line_offset(bytes_len);
3480 let mut _prev_end_offset: usize = 0;
3481 if 1 > max_ordinal {
3482 return Ok(());
3483 }
3484
3485 let cur_offset: usize = (1 - 1) * envelope_size;
3488
3489 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3491
3492 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicsBand, 64>, D>(
3497 self.bands.as_ref().map(<fidl::encoding::Vector<DynamicsBand, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3498 encoder, offset + cur_offset, depth
3499 )?;
3500
3501 _prev_end_offset = cur_offset + envelope_size;
3502 if 2 > max_ordinal {
3503 return Ok(());
3504 }
3505
3506 let cur_offset: usize = (2 - 1) * envelope_size;
3509
3510 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3512
3513 fidl::encoding::encode_in_envelope_optional::<DynamicsSupportedControls, D>(
3518 self.supported_controls
3519 .as_ref()
3520 .map(<DynamicsSupportedControls as fidl::encoding::ValueTypeMarker>::borrow),
3521 encoder,
3522 offset + cur_offset,
3523 depth,
3524 )?;
3525
3526 _prev_end_offset = cur_offset + envelope_size;
3527
3528 Ok(())
3529 }
3530 }
3531
3532 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dynamics {
3533 #[inline(always)]
3534 fn new_empty() -> Self {
3535 Self::default()
3536 }
3537
3538 unsafe fn decode(
3539 &mut self,
3540 decoder: &mut fidl::encoding::Decoder<'_, D>,
3541 offset: usize,
3542 mut depth: fidl::encoding::Depth,
3543 ) -> fidl::Result<()> {
3544 decoder.debug_check_bounds::<Self>(offset);
3545 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3546 None => return Err(fidl::Error::NotNullable),
3547 Some(len) => len,
3548 };
3549 if len == 0 {
3551 return Ok(());
3552 };
3553 depth.increment()?;
3554 let envelope_size = 8;
3555 let bytes_len = len * envelope_size;
3556 let offset = decoder.out_of_line_offset(bytes_len)?;
3557 let mut _next_ordinal_to_read = 0;
3559 let mut next_offset = offset;
3560 let end_offset = offset + bytes_len;
3561 _next_ordinal_to_read += 1;
3562 if next_offset >= end_offset {
3563 return Ok(());
3564 }
3565
3566 while _next_ordinal_to_read < 1 {
3568 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3569 _next_ordinal_to_read += 1;
3570 next_offset += envelope_size;
3571 }
3572
3573 let next_out_of_line = decoder.next_out_of_line();
3574 let handles_before = decoder.remaining_handles();
3575 if let Some((inlined, num_bytes, num_handles)) =
3576 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3577 {
3578 let member_inline_size = <fidl::encoding::Vector<DynamicsBand, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3579 if inlined != (member_inline_size <= 4) {
3580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3581 }
3582 let inner_offset;
3583 let mut inner_depth = depth.clone();
3584 if inlined {
3585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3586 inner_offset = next_offset;
3587 } else {
3588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3589 inner_depth.increment()?;
3590 }
3591 let val_ref = self.bands.get_or_insert_with(
3592 || fidl::new_empty!(fidl::encoding::Vector<DynamicsBand, 64>, D),
3593 );
3594 fidl::decode!(fidl::encoding::Vector<DynamicsBand, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3595 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3596 {
3597 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3598 }
3599 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3600 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3601 }
3602 }
3603
3604 next_offset += envelope_size;
3605 _next_ordinal_to_read += 1;
3606 if next_offset >= end_offset {
3607 return Ok(());
3608 }
3609
3610 while _next_ordinal_to_read < 2 {
3612 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3613 _next_ordinal_to_read += 1;
3614 next_offset += envelope_size;
3615 }
3616
3617 let next_out_of_line = decoder.next_out_of_line();
3618 let handles_before = decoder.remaining_handles();
3619 if let Some((inlined, num_bytes, num_handles)) =
3620 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3621 {
3622 let member_inline_size =
3623 <DynamicsSupportedControls as fidl::encoding::TypeMarker>::inline_size(
3624 decoder.context,
3625 );
3626 if inlined != (member_inline_size <= 4) {
3627 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3628 }
3629 let inner_offset;
3630 let mut inner_depth = depth.clone();
3631 if inlined {
3632 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3633 inner_offset = next_offset;
3634 } else {
3635 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3636 inner_depth.increment()?;
3637 }
3638 let val_ref = self
3639 .supported_controls
3640 .get_or_insert_with(|| fidl::new_empty!(DynamicsSupportedControls, D));
3641 fidl::decode!(
3642 DynamicsSupportedControls,
3643 D,
3644 val_ref,
3645 decoder,
3646 inner_offset,
3647 inner_depth
3648 )?;
3649 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3650 {
3651 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3652 }
3653 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3654 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3655 }
3656 }
3657
3658 next_offset += envelope_size;
3659
3660 while next_offset < end_offset {
3662 _next_ordinal_to_read += 1;
3663 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3664 next_offset += envelope_size;
3665 }
3666
3667 Ok(())
3668 }
3669 }
3670
3671 impl DynamicsBand {
3672 #[inline(always)]
3673 fn max_ordinal_present(&self) -> u64 {
3674 if let Some(_) = self.id {
3675 return 1;
3676 }
3677 0
3678 }
3679 }
3680
3681 impl fidl::encoding::ValueTypeMarker for DynamicsBand {
3682 type Borrowed<'a> = &'a Self;
3683 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3684 value
3685 }
3686 }
3687
3688 unsafe impl fidl::encoding::TypeMarker for DynamicsBand {
3689 type Owned = Self;
3690
3691 #[inline(always)]
3692 fn inline_align(_context: fidl::encoding::Context) -> usize {
3693 8
3694 }
3695
3696 #[inline(always)]
3697 fn inline_size(_context: fidl::encoding::Context) -> usize {
3698 16
3699 }
3700 }
3701
3702 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsBand, D>
3703 for &DynamicsBand
3704 {
3705 unsafe fn encode(
3706 self,
3707 encoder: &mut fidl::encoding::Encoder<'_, D>,
3708 offset: usize,
3709 mut depth: fidl::encoding::Depth,
3710 ) -> fidl::Result<()> {
3711 encoder.debug_check_bounds::<DynamicsBand>(offset);
3712 let max_ordinal: u64 = self.max_ordinal_present();
3714 encoder.write_num(max_ordinal, offset);
3715 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3716 if max_ordinal == 0 {
3718 return Ok(());
3719 }
3720 depth.increment()?;
3721 let envelope_size = 8;
3722 let bytes_len = max_ordinal as usize * envelope_size;
3723 #[allow(unused_variables)]
3724 let offset = encoder.out_of_line_offset(bytes_len);
3725 let mut _prev_end_offset: usize = 0;
3726 if 1 > max_ordinal {
3727 return Ok(());
3728 }
3729
3730 let cur_offset: usize = (1 - 1) * envelope_size;
3733
3734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3736
3737 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3742 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3743 encoder,
3744 offset + cur_offset,
3745 depth,
3746 )?;
3747
3748 _prev_end_offset = cur_offset + envelope_size;
3749
3750 Ok(())
3751 }
3752 }
3753
3754 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsBand {
3755 #[inline(always)]
3756 fn new_empty() -> Self {
3757 Self::default()
3758 }
3759
3760 unsafe fn decode(
3761 &mut self,
3762 decoder: &mut fidl::encoding::Decoder<'_, D>,
3763 offset: usize,
3764 mut depth: fidl::encoding::Depth,
3765 ) -> fidl::Result<()> {
3766 decoder.debug_check_bounds::<Self>(offset);
3767 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3768 None => return Err(fidl::Error::NotNullable),
3769 Some(len) => len,
3770 };
3771 if len == 0 {
3773 return Ok(());
3774 };
3775 depth.increment()?;
3776 let envelope_size = 8;
3777 let bytes_len = len * envelope_size;
3778 let offset = decoder.out_of_line_offset(bytes_len)?;
3779 let mut _next_ordinal_to_read = 0;
3781 let mut next_offset = offset;
3782 let end_offset = offset + bytes_len;
3783 _next_ordinal_to_read += 1;
3784 if next_offset >= end_offset {
3785 return Ok(());
3786 }
3787
3788 while _next_ordinal_to_read < 1 {
3790 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3791 _next_ordinal_to_read += 1;
3792 next_offset += envelope_size;
3793 }
3794
3795 let next_out_of_line = decoder.next_out_of_line();
3796 let handles_before = decoder.remaining_handles();
3797 if let Some((inlined, num_bytes, num_handles)) =
3798 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3799 {
3800 let member_inline_size =
3801 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3802 if inlined != (member_inline_size <= 4) {
3803 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3804 }
3805 let inner_offset;
3806 let mut inner_depth = depth.clone();
3807 if inlined {
3808 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3809 inner_offset = next_offset;
3810 } else {
3811 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3812 inner_depth.increment()?;
3813 }
3814 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3815 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3816 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3817 {
3818 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3819 }
3820 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3821 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3822 }
3823 }
3824
3825 next_offset += envelope_size;
3826
3827 while next_offset < end_offset {
3829 _next_ordinal_to_read += 1;
3830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3831 next_offset += envelope_size;
3832 }
3833
3834 Ok(())
3835 }
3836 }
3837
3838 impl DynamicsBandState {
3839 #[inline(always)]
3840 fn max_ordinal_present(&self) -> u64 {
3841 if let Some(_) = self.linked_channels {
3842 return 14;
3843 }
3844 if let Some(_) = self.lookahead {
3845 return 13;
3846 }
3847 if let Some(_) = self.level_type {
3848 return 12;
3849 }
3850 if let Some(_) = self.input_gain_db {
3851 return 11;
3852 }
3853 if let Some(_) = self.output_gain_db {
3854 return 10;
3855 }
3856 if let Some(_) = self.release {
3857 return 9;
3858 }
3859 if let Some(_) = self.attack {
3860 return 8;
3861 }
3862 if let Some(_) = self.knee_width_db {
3863 return 7;
3864 }
3865 if let Some(_) = self.ratio {
3866 return 6;
3867 }
3868 if let Some(_) = self.threshold_type {
3869 return 5;
3870 }
3871 if let Some(_) = self.threshold_db {
3872 return 4;
3873 }
3874 if let Some(_) = self.max_frequency {
3875 return 3;
3876 }
3877 if let Some(_) = self.min_frequency {
3878 return 2;
3879 }
3880 if let Some(_) = self.id {
3881 return 1;
3882 }
3883 0
3884 }
3885 }
3886
3887 impl fidl::encoding::ValueTypeMarker for DynamicsBandState {
3888 type Borrowed<'a> = &'a Self;
3889 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3890 value
3891 }
3892 }
3893
3894 unsafe impl fidl::encoding::TypeMarker for DynamicsBandState {
3895 type Owned = Self;
3896
3897 #[inline(always)]
3898 fn inline_align(_context: fidl::encoding::Context) -> usize {
3899 8
3900 }
3901
3902 #[inline(always)]
3903 fn inline_size(_context: fidl::encoding::Context) -> usize {
3904 16
3905 }
3906 }
3907
3908 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsBandState, D>
3909 for &DynamicsBandState
3910 {
3911 unsafe fn encode(
3912 self,
3913 encoder: &mut fidl::encoding::Encoder<'_, D>,
3914 offset: usize,
3915 mut depth: fidl::encoding::Depth,
3916 ) -> fidl::Result<()> {
3917 encoder.debug_check_bounds::<DynamicsBandState>(offset);
3918 let max_ordinal: u64 = self.max_ordinal_present();
3920 encoder.write_num(max_ordinal, offset);
3921 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3922 if max_ordinal == 0 {
3924 return Ok(());
3925 }
3926 depth.increment()?;
3927 let envelope_size = 8;
3928 let bytes_len = max_ordinal as usize * envelope_size;
3929 #[allow(unused_variables)]
3930 let offset = encoder.out_of_line_offset(bytes_len);
3931 let mut _prev_end_offset: usize = 0;
3932 if 1 > max_ordinal {
3933 return Ok(());
3934 }
3935
3936 let cur_offset: usize = (1 - 1) * envelope_size;
3939
3940 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3942
3943 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3948 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3949 encoder,
3950 offset + cur_offset,
3951 depth,
3952 )?;
3953
3954 _prev_end_offset = cur_offset + envelope_size;
3955 if 2 > max_ordinal {
3956 return Ok(());
3957 }
3958
3959 let cur_offset: usize = (2 - 1) * envelope_size;
3962
3963 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3965
3966 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3971 self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3972 encoder,
3973 offset + cur_offset,
3974 depth,
3975 )?;
3976
3977 _prev_end_offset = cur_offset + envelope_size;
3978 if 3 > max_ordinal {
3979 return Ok(());
3980 }
3981
3982 let cur_offset: usize = (3 - 1) * envelope_size;
3985
3986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3988
3989 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3994 self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3995 encoder,
3996 offset + cur_offset,
3997 depth,
3998 )?;
3999
4000 _prev_end_offset = cur_offset + envelope_size;
4001 if 4 > max_ordinal {
4002 return Ok(());
4003 }
4004
4005 let cur_offset: usize = (4 - 1) * envelope_size;
4008
4009 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4011
4012 fidl::encoding::encode_in_envelope_optional::<f32, D>(
4017 self.threshold_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4018 encoder,
4019 offset + cur_offset,
4020 depth,
4021 )?;
4022
4023 _prev_end_offset = cur_offset + envelope_size;
4024 if 5 > max_ordinal {
4025 return Ok(());
4026 }
4027
4028 let cur_offset: usize = (5 - 1) * envelope_size;
4031
4032 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4034
4035 fidl::encoding::encode_in_envelope_optional::<ThresholdType, D>(
4040 self.threshold_type
4041 .as_ref()
4042 .map(<ThresholdType as fidl::encoding::ValueTypeMarker>::borrow),
4043 encoder,
4044 offset + cur_offset,
4045 depth,
4046 )?;
4047
4048 _prev_end_offset = cur_offset + envelope_size;
4049 if 6 > max_ordinal {
4050 return Ok(());
4051 }
4052
4053 let cur_offset: usize = (6 - 1) * envelope_size;
4056
4057 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4059
4060 fidl::encoding::encode_in_envelope_optional::<f32, D>(
4065 self.ratio.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4066 encoder,
4067 offset + cur_offset,
4068 depth,
4069 )?;
4070
4071 _prev_end_offset = cur_offset + envelope_size;
4072 if 7 > max_ordinal {
4073 return Ok(());
4074 }
4075
4076 let cur_offset: usize = (7 - 1) * envelope_size;
4079
4080 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4082
4083 fidl::encoding::encode_in_envelope_optional::<f32, D>(
4088 self.knee_width_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4089 encoder,
4090 offset + cur_offset,
4091 depth,
4092 )?;
4093
4094 _prev_end_offset = cur_offset + envelope_size;
4095 if 8 > max_ordinal {
4096 return Ok(());
4097 }
4098
4099 let cur_offset: usize = (8 - 1) * envelope_size;
4102
4103 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4105
4106 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4111 self.attack.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4112 encoder,
4113 offset + cur_offset,
4114 depth,
4115 )?;
4116
4117 _prev_end_offset = cur_offset + envelope_size;
4118 if 9 > max_ordinal {
4119 return Ok(());
4120 }
4121
4122 let cur_offset: usize = (9 - 1) * envelope_size;
4125
4126 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4128
4129 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4134 self.release.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4135 encoder,
4136 offset + cur_offset,
4137 depth,
4138 )?;
4139
4140 _prev_end_offset = cur_offset + envelope_size;
4141 if 10 > max_ordinal {
4142 return Ok(());
4143 }
4144
4145 let cur_offset: usize = (10 - 1) * envelope_size;
4148
4149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4151
4152 fidl::encoding::encode_in_envelope_optional::<f32, D>(
4157 self.output_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4158 encoder,
4159 offset + cur_offset,
4160 depth,
4161 )?;
4162
4163 _prev_end_offset = cur_offset + envelope_size;
4164 if 11 > max_ordinal {
4165 return Ok(());
4166 }
4167
4168 let cur_offset: usize = (11 - 1) * envelope_size;
4171
4172 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4174
4175 fidl::encoding::encode_in_envelope_optional::<f32, D>(
4180 self.input_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4181 encoder,
4182 offset + cur_offset,
4183 depth,
4184 )?;
4185
4186 _prev_end_offset = cur_offset + envelope_size;
4187 if 12 > max_ordinal {
4188 return Ok(());
4189 }
4190
4191 let cur_offset: usize = (12 - 1) * envelope_size;
4194
4195 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4197
4198 fidl::encoding::encode_in_envelope_optional::<LevelType, D>(
4203 self.level_type
4204 .as_ref()
4205 .map(<LevelType as fidl::encoding::ValueTypeMarker>::borrow),
4206 encoder,
4207 offset + cur_offset,
4208 depth,
4209 )?;
4210
4211 _prev_end_offset = cur_offset + envelope_size;
4212 if 13 > max_ordinal {
4213 return Ok(());
4214 }
4215
4216 let cur_offset: usize = (13 - 1) * envelope_size;
4219
4220 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4222
4223 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4228 self.lookahead.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4229 encoder,
4230 offset + cur_offset,
4231 depth,
4232 )?;
4233
4234 _prev_end_offset = cur_offset + envelope_size;
4235 if 14 > max_ordinal {
4236 return Ok(());
4237 }
4238
4239 let cur_offset: usize = (14 - 1) * envelope_size;
4242
4243 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4245
4246 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4251 self.linked_channels
4252 .as_ref()
4253 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4254 encoder,
4255 offset + cur_offset,
4256 depth,
4257 )?;
4258
4259 _prev_end_offset = cur_offset + envelope_size;
4260
4261 Ok(())
4262 }
4263 }
4264
4265 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsBandState {
4266 #[inline(always)]
4267 fn new_empty() -> Self {
4268 Self::default()
4269 }
4270
4271 unsafe fn decode(
4272 &mut self,
4273 decoder: &mut fidl::encoding::Decoder<'_, D>,
4274 offset: usize,
4275 mut depth: fidl::encoding::Depth,
4276 ) -> fidl::Result<()> {
4277 decoder.debug_check_bounds::<Self>(offset);
4278 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4279 None => return Err(fidl::Error::NotNullable),
4280 Some(len) => len,
4281 };
4282 if len == 0 {
4284 return Ok(());
4285 };
4286 depth.increment()?;
4287 let envelope_size = 8;
4288 let bytes_len = len * envelope_size;
4289 let offset = decoder.out_of_line_offset(bytes_len)?;
4290 let mut _next_ordinal_to_read = 0;
4292 let mut next_offset = offset;
4293 let end_offset = offset + bytes_len;
4294 _next_ordinal_to_read += 1;
4295 if next_offset >= end_offset {
4296 return Ok(());
4297 }
4298
4299 while _next_ordinal_to_read < 1 {
4301 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4302 _next_ordinal_to_read += 1;
4303 next_offset += envelope_size;
4304 }
4305
4306 let next_out_of_line = decoder.next_out_of_line();
4307 let handles_before = decoder.remaining_handles();
4308 if let Some((inlined, num_bytes, num_handles)) =
4309 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4310 {
4311 let member_inline_size =
4312 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4313 if inlined != (member_inline_size <= 4) {
4314 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4315 }
4316 let inner_offset;
4317 let mut inner_depth = depth.clone();
4318 if inlined {
4319 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4320 inner_offset = next_offset;
4321 } else {
4322 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4323 inner_depth.increment()?;
4324 }
4325 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4326 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4327 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4328 {
4329 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4330 }
4331 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4332 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4333 }
4334 }
4335
4336 next_offset += envelope_size;
4337 _next_ordinal_to_read += 1;
4338 if next_offset >= end_offset {
4339 return Ok(());
4340 }
4341
4342 while _next_ordinal_to_read < 2 {
4344 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4345 _next_ordinal_to_read += 1;
4346 next_offset += envelope_size;
4347 }
4348
4349 let next_out_of_line = decoder.next_out_of_line();
4350 let handles_before = decoder.remaining_handles();
4351 if let Some((inlined, num_bytes, num_handles)) =
4352 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4353 {
4354 let member_inline_size =
4355 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4356 if inlined != (member_inline_size <= 4) {
4357 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4358 }
4359 let inner_offset;
4360 let mut inner_depth = depth.clone();
4361 if inlined {
4362 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4363 inner_offset = next_offset;
4364 } else {
4365 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4366 inner_depth.increment()?;
4367 }
4368 let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
4369 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4370 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4371 {
4372 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4373 }
4374 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4375 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4376 }
4377 }
4378
4379 next_offset += envelope_size;
4380 _next_ordinal_to_read += 1;
4381 if next_offset >= end_offset {
4382 return Ok(());
4383 }
4384
4385 while _next_ordinal_to_read < 3 {
4387 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4388 _next_ordinal_to_read += 1;
4389 next_offset += envelope_size;
4390 }
4391
4392 let next_out_of_line = decoder.next_out_of_line();
4393 let handles_before = decoder.remaining_handles();
4394 if let Some((inlined, num_bytes, num_handles)) =
4395 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4396 {
4397 let member_inline_size =
4398 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4399 if inlined != (member_inline_size <= 4) {
4400 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4401 }
4402 let inner_offset;
4403 let mut inner_depth = depth.clone();
4404 if inlined {
4405 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4406 inner_offset = next_offset;
4407 } else {
4408 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4409 inner_depth.increment()?;
4410 }
4411 let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
4412 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4414 {
4415 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4416 }
4417 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4418 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4419 }
4420 }
4421
4422 next_offset += envelope_size;
4423 _next_ordinal_to_read += 1;
4424 if next_offset >= end_offset {
4425 return Ok(());
4426 }
4427
4428 while _next_ordinal_to_read < 4 {
4430 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4431 _next_ordinal_to_read += 1;
4432 next_offset += envelope_size;
4433 }
4434
4435 let next_out_of_line = decoder.next_out_of_line();
4436 let handles_before = decoder.remaining_handles();
4437 if let Some((inlined, num_bytes, num_handles)) =
4438 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4439 {
4440 let member_inline_size =
4441 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4442 if inlined != (member_inline_size <= 4) {
4443 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4444 }
4445 let inner_offset;
4446 let mut inner_depth = depth.clone();
4447 if inlined {
4448 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4449 inner_offset = next_offset;
4450 } else {
4451 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4452 inner_depth.increment()?;
4453 }
4454 let val_ref = self.threshold_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4455 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4456 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4457 {
4458 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4459 }
4460 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4461 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4462 }
4463 }
4464
4465 next_offset += envelope_size;
4466 _next_ordinal_to_read += 1;
4467 if next_offset >= end_offset {
4468 return Ok(());
4469 }
4470
4471 while _next_ordinal_to_read < 5 {
4473 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4474 _next_ordinal_to_read += 1;
4475 next_offset += envelope_size;
4476 }
4477
4478 let next_out_of_line = decoder.next_out_of_line();
4479 let handles_before = decoder.remaining_handles();
4480 if let Some((inlined, num_bytes, num_handles)) =
4481 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4482 {
4483 let member_inline_size =
4484 <ThresholdType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4485 if inlined != (member_inline_size <= 4) {
4486 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4487 }
4488 let inner_offset;
4489 let mut inner_depth = depth.clone();
4490 if inlined {
4491 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4492 inner_offset = next_offset;
4493 } else {
4494 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4495 inner_depth.increment()?;
4496 }
4497 let val_ref =
4498 self.threshold_type.get_or_insert_with(|| fidl::new_empty!(ThresholdType, D));
4499 fidl::decode!(ThresholdType, D, val_ref, decoder, inner_offset, inner_depth)?;
4500 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4501 {
4502 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4503 }
4504 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4505 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4506 }
4507 }
4508
4509 next_offset += envelope_size;
4510 _next_ordinal_to_read += 1;
4511 if next_offset >= end_offset {
4512 return Ok(());
4513 }
4514
4515 while _next_ordinal_to_read < 6 {
4517 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4518 _next_ordinal_to_read += 1;
4519 next_offset += envelope_size;
4520 }
4521
4522 let next_out_of_line = decoder.next_out_of_line();
4523 let handles_before = decoder.remaining_handles();
4524 if let Some((inlined, num_bytes, num_handles)) =
4525 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4526 {
4527 let member_inline_size =
4528 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4529 if inlined != (member_inline_size <= 4) {
4530 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4531 }
4532 let inner_offset;
4533 let mut inner_depth = depth.clone();
4534 if inlined {
4535 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4536 inner_offset = next_offset;
4537 } else {
4538 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4539 inner_depth.increment()?;
4540 }
4541 let val_ref = self.ratio.get_or_insert_with(|| fidl::new_empty!(f32, D));
4542 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4543 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4544 {
4545 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4546 }
4547 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4548 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4549 }
4550 }
4551
4552 next_offset += envelope_size;
4553 _next_ordinal_to_read += 1;
4554 if next_offset >= end_offset {
4555 return Ok(());
4556 }
4557
4558 while _next_ordinal_to_read < 7 {
4560 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4561 _next_ordinal_to_read += 1;
4562 next_offset += envelope_size;
4563 }
4564
4565 let next_out_of_line = decoder.next_out_of_line();
4566 let handles_before = decoder.remaining_handles();
4567 if let Some((inlined, num_bytes, num_handles)) =
4568 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4569 {
4570 let member_inline_size =
4571 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4572 if inlined != (member_inline_size <= 4) {
4573 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4574 }
4575 let inner_offset;
4576 let mut inner_depth = depth.clone();
4577 if inlined {
4578 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4579 inner_offset = next_offset;
4580 } else {
4581 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4582 inner_depth.increment()?;
4583 }
4584 let val_ref = self.knee_width_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4585 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4586 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4587 {
4588 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4589 }
4590 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4591 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4592 }
4593 }
4594
4595 next_offset += envelope_size;
4596 _next_ordinal_to_read += 1;
4597 if next_offset >= end_offset {
4598 return Ok(());
4599 }
4600
4601 while _next_ordinal_to_read < 8 {
4603 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4604 _next_ordinal_to_read += 1;
4605 next_offset += envelope_size;
4606 }
4607
4608 let next_out_of_line = decoder.next_out_of_line();
4609 let handles_before = decoder.remaining_handles();
4610 if let Some((inlined, num_bytes, num_handles)) =
4611 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4612 {
4613 let member_inline_size =
4614 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4615 if inlined != (member_inline_size <= 4) {
4616 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4617 }
4618 let inner_offset;
4619 let mut inner_depth = depth.clone();
4620 if inlined {
4621 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4622 inner_offset = next_offset;
4623 } else {
4624 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4625 inner_depth.increment()?;
4626 }
4627 let val_ref = self.attack.get_or_insert_with(|| fidl::new_empty!(i64, D));
4628 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4629 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4630 {
4631 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4632 }
4633 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4634 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4635 }
4636 }
4637
4638 next_offset += envelope_size;
4639 _next_ordinal_to_read += 1;
4640 if next_offset >= end_offset {
4641 return Ok(());
4642 }
4643
4644 while _next_ordinal_to_read < 9 {
4646 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4647 _next_ordinal_to_read += 1;
4648 next_offset += envelope_size;
4649 }
4650
4651 let next_out_of_line = decoder.next_out_of_line();
4652 let handles_before = decoder.remaining_handles();
4653 if let Some((inlined, num_bytes, num_handles)) =
4654 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4655 {
4656 let member_inline_size =
4657 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4658 if inlined != (member_inline_size <= 4) {
4659 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4660 }
4661 let inner_offset;
4662 let mut inner_depth = depth.clone();
4663 if inlined {
4664 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4665 inner_offset = next_offset;
4666 } else {
4667 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4668 inner_depth.increment()?;
4669 }
4670 let val_ref = self.release.get_or_insert_with(|| fidl::new_empty!(i64, D));
4671 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4672 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4673 {
4674 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4675 }
4676 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4677 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4678 }
4679 }
4680
4681 next_offset += envelope_size;
4682 _next_ordinal_to_read += 1;
4683 if next_offset >= end_offset {
4684 return Ok(());
4685 }
4686
4687 while _next_ordinal_to_read < 10 {
4689 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4690 _next_ordinal_to_read += 1;
4691 next_offset += envelope_size;
4692 }
4693
4694 let next_out_of_line = decoder.next_out_of_line();
4695 let handles_before = decoder.remaining_handles();
4696 if let Some((inlined, num_bytes, num_handles)) =
4697 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4698 {
4699 let member_inline_size =
4700 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4701 if inlined != (member_inline_size <= 4) {
4702 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4703 }
4704 let inner_offset;
4705 let mut inner_depth = depth.clone();
4706 if inlined {
4707 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4708 inner_offset = next_offset;
4709 } else {
4710 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4711 inner_depth.increment()?;
4712 }
4713 let val_ref = self.output_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4714 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4715 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4716 {
4717 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4718 }
4719 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4720 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4721 }
4722 }
4723
4724 next_offset += envelope_size;
4725 _next_ordinal_to_read += 1;
4726 if next_offset >= end_offset {
4727 return Ok(());
4728 }
4729
4730 while _next_ordinal_to_read < 11 {
4732 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4733 _next_ordinal_to_read += 1;
4734 next_offset += envelope_size;
4735 }
4736
4737 let next_out_of_line = decoder.next_out_of_line();
4738 let handles_before = decoder.remaining_handles();
4739 if let Some((inlined, num_bytes, num_handles)) =
4740 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4741 {
4742 let member_inline_size =
4743 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4744 if inlined != (member_inline_size <= 4) {
4745 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4746 }
4747 let inner_offset;
4748 let mut inner_depth = depth.clone();
4749 if inlined {
4750 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4751 inner_offset = next_offset;
4752 } else {
4753 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4754 inner_depth.increment()?;
4755 }
4756 let val_ref = self.input_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4757 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4758 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4759 {
4760 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4761 }
4762 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4763 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4764 }
4765 }
4766
4767 next_offset += envelope_size;
4768 _next_ordinal_to_read += 1;
4769 if next_offset >= end_offset {
4770 return Ok(());
4771 }
4772
4773 while _next_ordinal_to_read < 12 {
4775 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4776 _next_ordinal_to_read += 1;
4777 next_offset += envelope_size;
4778 }
4779
4780 let next_out_of_line = decoder.next_out_of_line();
4781 let handles_before = decoder.remaining_handles();
4782 if let Some((inlined, num_bytes, num_handles)) =
4783 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4784 {
4785 let member_inline_size =
4786 <LevelType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4787 if inlined != (member_inline_size <= 4) {
4788 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4789 }
4790 let inner_offset;
4791 let mut inner_depth = depth.clone();
4792 if inlined {
4793 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4794 inner_offset = next_offset;
4795 } else {
4796 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4797 inner_depth.increment()?;
4798 }
4799 let val_ref = self.level_type.get_or_insert_with(|| fidl::new_empty!(LevelType, D));
4800 fidl::decode!(LevelType, D, val_ref, decoder, inner_offset, inner_depth)?;
4801 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4802 {
4803 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4804 }
4805 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4806 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4807 }
4808 }
4809
4810 next_offset += envelope_size;
4811 _next_ordinal_to_read += 1;
4812 if next_offset >= end_offset {
4813 return Ok(());
4814 }
4815
4816 while _next_ordinal_to_read < 13 {
4818 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4819 _next_ordinal_to_read += 1;
4820 next_offset += envelope_size;
4821 }
4822
4823 let next_out_of_line = decoder.next_out_of_line();
4824 let handles_before = decoder.remaining_handles();
4825 if let Some((inlined, num_bytes, num_handles)) =
4826 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4827 {
4828 let member_inline_size =
4829 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4830 if inlined != (member_inline_size <= 4) {
4831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4832 }
4833 let inner_offset;
4834 let mut inner_depth = depth.clone();
4835 if inlined {
4836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4837 inner_offset = next_offset;
4838 } else {
4839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4840 inner_depth.increment()?;
4841 }
4842 let val_ref = self.lookahead.get_or_insert_with(|| fidl::new_empty!(i64, D));
4843 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4845 {
4846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4847 }
4848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4850 }
4851 }
4852
4853 next_offset += envelope_size;
4854 _next_ordinal_to_read += 1;
4855 if next_offset >= end_offset {
4856 return Ok(());
4857 }
4858
4859 while _next_ordinal_to_read < 14 {
4861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4862 _next_ordinal_to_read += 1;
4863 next_offset += envelope_size;
4864 }
4865
4866 let next_out_of_line = decoder.next_out_of_line();
4867 let handles_before = decoder.remaining_handles();
4868 if let Some((inlined, num_bytes, num_handles)) =
4869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4870 {
4871 let member_inline_size =
4872 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4873 if inlined != (member_inline_size <= 4) {
4874 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4875 }
4876 let inner_offset;
4877 let mut inner_depth = depth.clone();
4878 if inlined {
4879 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4880 inner_offset = next_offset;
4881 } else {
4882 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4883 inner_depth.increment()?;
4884 }
4885 let val_ref = self.linked_channels.get_or_insert_with(|| fidl::new_empty!(bool, D));
4886 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4888 {
4889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4890 }
4891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4893 }
4894 }
4895
4896 next_offset += envelope_size;
4897
4898 while next_offset < end_offset {
4900 _next_ordinal_to_read += 1;
4901 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4902 next_offset += envelope_size;
4903 }
4904
4905 Ok(())
4906 }
4907 }
4908
4909 impl DynamicsElementState {
4910 #[inline(always)]
4911 fn max_ordinal_present(&self) -> u64 {
4912 if let Some(_) = self.band_states {
4913 return 1;
4914 }
4915 0
4916 }
4917 }
4918
4919 impl fidl::encoding::ValueTypeMarker for DynamicsElementState {
4920 type Borrowed<'a> = &'a Self;
4921 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4922 value
4923 }
4924 }
4925
4926 unsafe impl fidl::encoding::TypeMarker for DynamicsElementState {
4927 type Owned = Self;
4928
4929 #[inline(always)]
4930 fn inline_align(_context: fidl::encoding::Context) -> usize {
4931 8
4932 }
4933
4934 #[inline(always)]
4935 fn inline_size(_context: fidl::encoding::Context) -> usize {
4936 16
4937 }
4938 }
4939
4940 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsElementState, D>
4941 for &DynamicsElementState
4942 {
4943 unsafe fn encode(
4944 self,
4945 encoder: &mut fidl::encoding::Encoder<'_, D>,
4946 offset: usize,
4947 mut depth: fidl::encoding::Depth,
4948 ) -> fidl::Result<()> {
4949 encoder.debug_check_bounds::<DynamicsElementState>(offset);
4950 let max_ordinal: u64 = self.max_ordinal_present();
4952 encoder.write_num(max_ordinal, offset);
4953 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4954 if max_ordinal == 0 {
4956 return Ok(());
4957 }
4958 depth.increment()?;
4959 let envelope_size = 8;
4960 let bytes_len = max_ordinal as usize * envelope_size;
4961 #[allow(unused_variables)]
4962 let offset = encoder.out_of_line_offset(bytes_len);
4963 let mut _prev_end_offset: usize = 0;
4964 if 1 > max_ordinal {
4965 return Ok(());
4966 }
4967
4968 let cur_offset: usize = (1 - 1) * envelope_size;
4971
4972 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4974
4975 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicsBandState, 64>, D>(
4980 self.band_states.as_ref().map(<fidl::encoding::Vector<DynamicsBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
4981 encoder, offset + cur_offset, depth
4982 )?;
4983
4984 _prev_end_offset = cur_offset + envelope_size;
4985
4986 Ok(())
4987 }
4988 }
4989
4990 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsElementState {
4991 #[inline(always)]
4992 fn new_empty() -> Self {
4993 Self::default()
4994 }
4995
4996 unsafe fn decode(
4997 &mut self,
4998 decoder: &mut fidl::encoding::Decoder<'_, D>,
4999 offset: usize,
5000 mut depth: fidl::encoding::Depth,
5001 ) -> fidl::Result<()> {
5002 decoder.debug_check_bounds::<Self>(offset);
5003 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5004 None => return Err(fidl::Error::NotNullable),
5005 Some(len) => len,
5006 };
5007 if len == 0 {
5009 return Ok(());
5010 };
5011 depth.increment()?;
5012 let envelope_size = 8;
5013 let bytes_len = len * envelope_size;
5014 let offset = decoder.out_of_line_offset(bytes_len)?;
5015 let mut _next_ordinal_to_read = 0;
5017 let mut next_offset = offset;
5018 let end_offset = offset + bytes_len;
5019 _next_ordinal_to_read += 1;
5020 if next_offset >= end_offset {
5021 return Ok(());
5022 }
5023
5024 while _next_ordinal_to_read < 1 {
5026 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5027 _next_ordinal_to_read += 1;
5028 next_offset += envelope_size;
5029 }
5030
5031 let next_out_of_line = decoder.next_out_of_line();
5032 let handles_before = decoder.remaining_handles();
5033 if let Some((inlined, num_bytes, num_handles)) =
5034 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5035 {
5036 let member_inline_size = <fidl::encoding::Vector<DynamicsBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5037 if inlined != (member_inline_size <= 4) {
5038 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5039 }
5040 let inner_offset;
5041 let mut inner_depth = depth.clone();
5042 if inlined {
5043 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5044 inner_offset = next_offset;
5045 } else {
5046 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5047 inner_depth.increment()?;
5048 }
5049 let val_ref = self.band_states.get_or_insert_with(
5050 || fidl::new_empty!(fidl::encoding::Vector<DynamicsBandState, 64>, D),
5051 );
5052 fidl::decode!(fidl::encoding::Vector<DynamicsBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5053 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5054 {
5055 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5056 }
5057 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5058 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5059 }
5060 }
5061
5062 next_offset += envelope_size;
5063
5064 while next_offset < end_offset {
5066 _next_ordinal_to_read += 1;
5067 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5068 next_offset += envelope_size;
5069 }
5070
5071 Ok(())
5072 }
5073 }
5074
5075 impl Element {
5076 #[inline(always)]
5077 fn max_ordinal_present(&self) -> u64 {
5078 if let Some(_) = self.can_bypass {
5079 return 7;
5080 }
5081 if let Some(_) = self.can_stop {
5082 return 6;
5083 }
5084 if let Some(_) = self.description {
5085 return 5;
5086 }
5087 if let Some(_) = self.can_disable {
5088 return 4;
5089 }
5090 if let Some(_) = self.type_specific {
5091 return 3;
5092 }
5093 if let Some(_) = self.type_ {
5094 return 2;
5095 }
5096 if let Some(_) = self.id {
5097 return 1;
5098 }
5099 0
5100 }
5101 }
5102
5103 impl fidl::encoding::ValueTypeMarker for Element {
5104 type Borrowed<'a> = &'a Self;
5105 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5106 value
5107 }
5108 }
5109
5110 unsafe impl fidl::encoding::TypeMarker for Element {
5111 type Owned = Self;
5112
5113 #[inline(always)]
5114 fn inline_align(_context: fidl::encoding::Context) -> usize {
5115 8
5116 }
5117
5118 #[inline(always)]
5119 fn inline_size(_context: fidl::encoding::Context) -> usize {
5120 16
5121 }
5122 }
5123
5124 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Element, D> for &Element {
5125 unsafe fn encode(
5126 self,
5127 encoder: &mut fidl::encoding::Encoder<'_, D>,
5128 offset: usize,
5129 mut depth: fidl::encoding::Depth,
5130 ) -> fidl::Result<()> {
5131 encoder.debug_check_bounds::<Element>(offset);
5132 let max_ordinal: u64 = self.max_ordinal_present();
5134 encoder.write_num(max_ordinal, offset);
5135 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5136 if max_ordinal == 0 {
5138 return Ok(());
5139 }
5140 depth.increment()?;
5141 let envelope_size = 8;
5142 let bytes_len = max_ordinal as usize * envelope_size;
5143 #[allow(unused_variables)]
5144 let offset = encoder.out_of_line_offset(bytes_len);
5145 let mut _prev_end_offset: usize = 0;
5146 if 1 > max_ordinal {
5147 return Ok(());
5148 }
5149
5150 let cur_offset: usize = (1 - 1) * envelope_size;
5153
5154 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5156
5157 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5162 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5163 encoder,
5164 offset + cur_offset,
5165 depth,
5166 )?;
5167
5168 _prev_end_offset = cur_offset + envelope_size;
5169 if 2 > max_ordinal {
5170 return Ok(());
5171 }
5172
5173 let cur_offset: usize = (2 - 1) * envelope_size;
5176
5177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5179
5180 fidl::encoding::encode_in_envelope_optional::<ElementType, D>(
5185 self.type_.as_ref().map(<ElementType as fidl::encoding::ValueTypeMarker>::borrow),
5186 encoder,
5187 offset + cur_offset,
5188 depth,
5189 )?;
5190
5191 _prev_end_offset = cur_offset + envelope_size;
5192 if 3 > max_ordinal {
5193 return Ok(());
5194 }
5195
5196 let cur_offset: usize = (3 - 1) * envelope_size;
5199
5200 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5202
5203 fidl::encoding::encode_in_envelope_optional::<TypeSpecificElement, D>(
5208 self.type_specific
5209 .as_ref()
5210 .map(<TypeSpecificElement as fidl::encoding::ValueTypeMarker>::borrow),
5211 encoder,
5212 offset + cur_offset,
5213 depth,
5214 )?;
5215
5216 _prev_end_offset = cur_offset + envelope_size;
5217 if 4 > max_ordinal {
5218 return Ok(());
5219 }
5220
5221 let cur_offset: usize = (4 - 1) * envelope_size;
5224
5225 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5227
5228 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5233 self.can_disable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5234 encoder,
5235 offset + cur_offset,
5236 depth,
5237 )?;
5238
5239 _prev_end_offset = cur_offset + envelope_size;
5240 if 5 > max_ordinal {
5241 return Ok(());
5242 }
5243
5244 let cur_offset: usize = (5 - 1) * envelope_size;
5247
5248 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5250
5251 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5256 self.description.as_ref().map(
5257 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5258 ),
5259 encoder,
5260 offset + cur_offset,
5261 depth,
5262 )?;
5263
5264 _prev_end_offset = cur_offset + envelope_size;
5265 if 6 > max_ordinal {
5266 return Ok(());
5267 }
5268
5269 let cur_offset: usize = (6 - 1) * envelope_size;
5272
5273 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5275
5276 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5281 self.can_stop.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5282 encoder,
5283 offset + cur_offset,
5284 depth,
5285 )?;
5286
5287 _prev_end_offset = cur_offset + envelope_size;
5288 if 7 > max_ordinal {
5289 return Ok(());
5290 }
5291
5292 let cur_offset: usize = (7 - 1) * envelope_size;
5295
5296 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5298
5299 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5304 self.can_bypass.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5305 encoder,
5306 offset + cur_offset,
5307 depth,
5308 )?;
5309
5310 _prev_end_offset = cur_offset + envelope_size;
5311
5312 Ok(())
5313 }
5314 }
5315
5316 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Element {
5317 #[inline(always)]
5318 fn new_empty() -> Self {
5319 Self::default()
5320 }
5321
5322 unsafe fn decode(
5323 &mut self,
5324 decoder: &mut fidl::encoding::Decoder<'_, D>,
5325 offset: usize,
5326 mut depth: fidl::encoding::Depth,
5327 ) -> fidl::Result<()> {
5328 decoder.debug_check_bounds::<Self>(offset);
5329 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5330 None => return Err(fidl::Error::NotNullable),
5331 Some(len) => len,
5332 };
5333 if len == 0 {
5335 return Ok(());
5336 };
5337 depth.increment()?;
5338 let envelope_size = 8;
5339 let bytes_len = len * envelope_size;
5340 let offset = decoder.out_of_line_offset(bytes_len)?;
5341 let mut _next_ordinal_to_read = 0;
5343 let mut next_offset = offset;
5344 let end_offset = offset + bytes_len;
5345 _next_ordinal_to_read += 1;
5346 if next_offset >= end_offset {
5347 return Ok(());
5348 }
5349
5350 while _next_ordinal_to_read < 1 {
5352 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5353 _next_ordinal_to_read += 1;
5354 next_offset += envelope_size;
5355 }
5356
5357 let next_out_of_line = decoder.next_out_of_line();
5358 let handles_before = decoder.remaining_handles();
5359 if let Some((inlined, num_bytes, num_handles)) =
5360 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5361 {
5362 let member_inline_size =
5363 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5364 if inlined != (member_inline_size <= 4) {
5365 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5366 }
5367 let inner_offset;
5368 let mut inner_depth = depth.clone();
5369 if inlined {
5370 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5371 inner_offset = next_offset;
5372 } else {
5373 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5374 inner_depth.increment()?;
5375 }
5376 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5377 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5379 {
5380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5381 }
5382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5384 }
5385 }
5386
5387 next_offset += envelope_size;
5388 _next_ordinal_to_read += 1;
5389 if next_offset >= end_offset {
5390 return Ok(());
5391 }
5392
5393 while _next_ordinal_to_read < 2 {
5395 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5396 _next_ordinal_to_read += 1;
5397 next_offset += envelope_size;
5398 }
5399
5400 let next_out_of_line = decoder.next_out_of_line();
5401 let handles_before = decoder.remaining_handles();
5402 if let Some((inlined, num_bytes, num_handles)) =
5403 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5404 {
5405 let member_inline_size =
5406 <ElementType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5407 if inlined != (member_inline_size <= 4) {
5408 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5409 }
5410 let inner_offset;
5411 let mut inner_depth = depth.clone();
5412 if inlined {
5413 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5414 inner_offset = next_offset;
5415 } else {
5416 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5417 inner_depth.increment()?;
5418 }
5419 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ElementType, D));
5420 fidl::decode!(ElementType, D, val_ref, decoder, inner_offset, inner_depth)?;
5421 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5422 {
5423 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5424 }
5425 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5426 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5427 }
5428 }
5429
5430 next_offset += envelope_size;
5431 _next_ordinal_to_read += 1;
5432 if next_offset >= end_offset {
5433 return Ok(());
5434 }
5435
5436 while _next_ordinal_to_read < 3 {
5438 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5439 _next_ordinal_to_read += 1;
5440 next_offset += envelope_size;
5441 }
5442
5443 let next_out_of_line = decoder.next_out_of_line();
5444 let handles_before = decoder.remaining_handles();
5445 if let Some((inlined, num_bytes, num_handles)) =
5446 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5447 {
5448 let member_inline_size =
5449 <TypeSpecificElement as fidl::encoding::TypeMarker>::inline_size(
5450 decoder.context,
5451 );
5452 if inlined != (member_inline_size <= 4) {
5453 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5454 }
5455 let inner_offset;
5456 let mut inner_depth = depth.clone();
5457 if inlined {
5458 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5459 inner_offset = next_offset;
5460 } else {
5461 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5462 inner_depth.increment()?;
5463 }
5464 let val_ref = self
5465 .type_specific
5466 .get_or_insert_with(|| fidl::new_empty!(TypeSpecificElement, D));
5467 fidl::decode!(TypeSpecificElement, D, val_ref, decoder, inner_offset, inner_depth)?;
5468 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5469 {
5470 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5471 }
5472 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5473 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5474 }
5475 }
5476
5477 next_offset += envelope_size;
5478 _next_ordinal_to_read += 1;
5479 if next_offset >= end_offset {
5480 return Ok(());
5481 }
5482
5483 while _next_ordinal_to_read < 4 {
5485 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5486 _next_ordinal_to_read += 1;
5487 next_offset += envelope_size;
5488 }
5489
5490 let next_out_of_line = decoder.next_out_of_line();
5491 let handles_before = decoder.remaining_handles();
5492 if let Some((inlined, num_bytes, num_handles)) =
5493 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5494 {
5495 let member_inline_size =
5496 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5497 if inlined != (member_inline_size <= 4) {
5498 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5499 }
5500 let inner_offset;
5501 let mut inner_depth = depth.clone();
5502 if inlined {
5503 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5504 inner_offset = next_offset;
5505 } else {
5506 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5507 inner_depth.increment()?;
5508 }
5509 let val_ref = self.can_disable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5510 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5511 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5512 {
5513 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5514 }
5515 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5516 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5517 }
5518 }
5519
5520 next_offset += envelope_size;
5521 _next_ordinal_to_read += 1;
5522 if next_offset >= end_offset {
5523 return Ok(());
5524 }
5525
5526 while _next_ordinal_to_read < 5 {
5528 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5529 _next_ordinal_to_read += 1;
5530 next_offset += envelope_size;
5531 }
5532
5533 let next_out_of_line = decoder.next_out_of_line();
5534 let handles_before = decoder.remaining_handles();
5535 if let Some((inlined, num_bytes, num_handles)) =
5536 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5537 {
5538 let member_inline_size =
5539 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5540 decoder.context,
5541 );
5542 if inlined != (member_inline_size <= 4) {
5543 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5544 }
5545 let inner_offset;
5546 let mut inner_depth = depth.clone();
5547 if inlined {
5548 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5549 inner_offset = next_offset;
5550 } else {
5551 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5552 inner_depth.increment()?;
5553 }
5554 let val_ref = self
5555 .description
5556 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5557 fidl::decode!(
5558 fidl::encoding::BoundedString<256>,
5559 D,
5560 val_ref,
5561 decoder,
5562 inner_offset,
5563 inner_depth
5564 )?;
5565 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5566 {
5567 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5568 }
5569 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5570 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5571 }
5572 }
5573
5574 next_offset += envelope_size;
5575 _next_ordinal_to_read += 1;
5576 if next_offset >= end_offset {
5577 return Ok(());
5578 }
5579
5580 while _next_ordinal_to_read < 6 {
5582 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5583 _next_ordinal_to_read += 1;
5584 next_offset += envelope_size;
5585 }
5586
5587 let next_out_of_line = decoder.next_out_of_line();
5588 let handles_before = decoder.remaining_handles();
5589 if let Some((inlined, num_bytes, num_handles)) =
5590 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5591 {
5592 let member_inline_size =
5593 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5594 if inlined != (member_inline_size <= 4) {
5595 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5596 }
5597 let inner_offset;
5598 let mut inner_depth = depth.clone();
5599 if inlined {
5600 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5601 inner_offset = next_offset;
5602 } else {
5603 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5604 inner_depth.increment()?;
5605 }
5606 let val_ref = self.can_stop.get_or_insert_with(|| fidl::new_empty!(bool, D));
5607 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5608 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5609 {
5610 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5611 }
5612 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5613 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5614 }
5615 }
5616
5617 next_offset += envelope_size;
5618 _next_ordinal_to_read += 1;
5619 if next_offset >= end_offset {
5620 return Ok(());
5621 }
5622
5623 while _next_ordinal_to_read < 7 {
5625 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5626 _next_ordinal_to_read += 1;
5627 next_offset += envelope_size;
5628 }
5629
5630 let next_out_of_line = decoder.next_out_of_line();
5631 let handles_before = decoder.remaining_handles();
5632 if let Some((inlined, num_bytes, num_handles)) =
5633 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5634 {
5635 let member_inline_size =
5636 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5637 if inlined != (member_inline_size <= 4) {
5638 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5639 }
5640 let inner_offset;
5641 let mut inner_depth = depth.clone();
5642 if inlined {
5643 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5644 inner_offset = next_offset;
5645 } else {
5646 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5647 inner_depth.increment()?;
5648 }
5649 let val_ref = self.can_bypass.get_or_insert_with(|| fidl::new_empty!(bool, D));
5650 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5651 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5652 {
5653 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5654 }
5655 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5656 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5657 }
5658 }
5659
5660 next_offset += envelope_size;
5661
5662 while next_offset < end_offset {
5664 _next_ordinal_to_read += 1;
5665 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5666 next_offset += envelope_size;
5667 }
5668
5669 Ok(())
5670 }
5671 }
5672
5673 impl ElementState {
5674 #[inline(always)]
5675 fn max_ordinal_present(&self) -> u64 {
5676 if let Some(_) = self.processing_delay {
5677 return 9;
5678 }
5679 if let Some(_) = self.turn_off_delay {
5680 return 8;
5681 }
5682 if let Some(_) = self.turn_on_delay {
5683 return 7;
5684 }
5685 if let Some(_) = self.bypassed {
5686 return 6;
5687 }
5688 if let Some(_) = self.started {
5689 return 5;
5690 }
5691 if let Some(_) = self.vendor_specific_data {
5692 return 4;
5693 }
5694 if let Some(_) = self.latency {
5695 return 3;
5696 }
5697 if let Some(_) = self.enabled {
5698 return 2;
5699 }
5700 if let Some(_) = self.type_specific {
5701 return 1;
5702 }
5703 0
5704 }
5705 }
5706
5707 impl fidl::encoding::ValueTypeMarker for ElementState {
5708 type Borrowed<'a> = &'a Self;
5709 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5710 value
5711 }
5712 }
5713
5714 unsafe impl fidl::encoding::TypeMarker for ElementState {
5715 type Owned = Self;
5716
5717 #[inline(always)]
5718 fn inline_align(_context: fidl::encoding::Context) -> usize {
5719 8
5720 }
5721
5722 #[inline(always)]
5723 fn inline_size(_context: fidl::encoding::Context) -> usize {
5724 16
5725 }
5726 }
5727
5728 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementState, D>
5729 for &ElementState
5730 {
5731 unsafe fn encode(
5732 self,
5733 encoder: &mut fidl::encoding::Encoder<'_, D>,
5734 offset: usize,
5735 mut depth: fidl::encoding::Depth,
5736 ) -> fidl::Result<()> {
5737 encoder.debug_check_bounds::<ElementState>(offset);
5738 let max_ordinal: u64 = self.max_ordinal_present();
5740 encoder.write_num(max_ordinal, offset);
5741 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5742 if max_ordinal == 0 {
5744 return Ok(());
5745 }
5746 depth.increment()?;
5747 let envelope_size = 8;
5748 let bytes_len = max_ordinal as usize * envelope_size;
5749 #[allow(unused_variables)]
5750 let offset = encoder.out_of_line_offset(bytes_len);
5751 let mut _prev_end_offset: usize = 0;
5752 if 1 > max_ordinal {
5753 return Ok(());
5754 }
5755
5756 let cur_offset: usize = (1 - 1) * envelope_size;
5759
5760 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5762
5763 fidl::encoding::encode_in_envelope_optional::<TypeSpecificElementState, D>(
5768 self.type_specific
5769 .as_ref()
5770 .map(<TypeSpecificElementState as fidl::encoding::ValueTypeMarker>::borrow),
5771 encoder,
5772 offset + cur_offset,
5773 depth,
5774 )?;
5775
5776 _prev_end_offset = cur_offset + envelope_size;
5777 if 2 > max_ordinal {
5778 return Ok(());
5779 }
5780
5781 let cur_offset: usize = (2 - 1) * envelope_size;
5784
5785 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5787
5788 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5793 self.enabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5794 encoder,
5795 offset + cur_offset,
5796 depth,
5797 )?;
5798
5799 _prev_end_offset = cur_offset + envelope_size;
5800 if 3 > max_ordinal {
5801 return Ok(());
5802 }
5803
5804 let cur_offset: usize = (3 - 1) * envelope_size;
5807
5808 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5810
5811 fidl::encoding::encode_in_envelope_optional::<Latency, D>(
5816 self.latency.as_ref().map(<Latency as fidl::encoding::ValueTypeMarker>::borrow),
5817 encoder,
5818 offset + cur_offset,
5819 depth,
5820 )?;
5821
5822 _prev_end_offset = cur_offset + envelope_size;
5823 if 4 > max_ordinal {
5824 return Ok(());
5825 }
5826
5827 let cur_offset: usize = (4 - 1) * envelope_size;
5830
5831 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5833
5834 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4096>, D>(
5839 self.vendor_specific_data.as_ref().map(
5840 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow,
5841 ),
5842 encoder,
5843 offset + cur_offset,
5844 depth,
5845 )?;
5846
5847 _prev_end_offset = cur_offset + envelope_size;
5848 if 5 > max_ordinal {
5849 return Ok(());
5850 }
5851
5852 let cur_offset: usize = (5 - 1) * envelope_size;
5855
5856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5858
5859 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5864 self.started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5865 encoder,
5866 offset + cur_offset,
5867 depth,
5868 )?;
5869
5870 _prev_end_offset = cur_offset + envelope_size;
5871 if 6 > max_ordinal {
5872 return Ok(());
5873 }
5874
5875 let cur_offset: usize = (6 - 1) * envelope_size;
5878
5879 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5881
5882 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5887 self.bypassed.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5888 encoder,
5889 offset + cur_offset,
5890 depth,
5891 )?;
5892
5893 _prev_end_offset = cur_offset + envelope_size;
5894 if 7 > max_ordinal {
5895 return Ok(());
5896 }
5897
5898 let cur_offset: usize = (7 - 1) * envelope_size;
5901
5902 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5904
5905 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5910 self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5911 encoder,
5912 offset + cur_offset,
5913 depth,
5914 )?;
5915
5916 _prev_end_offset = cur_offset + envelope_size;
5917 if 8 > max_ordinal {
5918 return Ok(());
5919 }
5920
5921 let cur_offset: usize = (8 - 1) * envelope_size;
5924
5925 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5927
5928 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5933 self.turn_off_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5934 encoder,
5935 offset + cur_offset,
5936 depth,
5937 )?;
5938
5939 _prev_end_offset = cur_offset + envelope_size;
5940 if 9 > max_ordinal {
5941 return Ok(());
5942 }
5943
5944 let cur_offset: usize = (9 - 1) * envelope_size;
5947
5948 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5950
5951 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5956 self.processing_delay
5957 .as_ref()
5958 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5959 encoder,
5960 offset + cur_offset,
5961 depth,
5962 )?;
5963
5964 _prev_end_offset = cur_offset + envelope_size;
5965
5966 Ok(())
5967 }
5968 }
5969
5970 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementState {
5971 #[inline(always)]
5972 fn new_empty() -> Self {
5973 Self::default()
5974 }
5975
5976 unsafe fn decode(
5977 &mut self,
5978 decoder: &mut fidl::encoding::Decoder<'_, D>,
5979 offset: usize,
5980 mut depth: fidl::encoding::Depth,
5981 ) -> fidl::Result<()> {
5982 decoder.debug_check_bounds::<Self>(offset);
5983 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5984 None => return Err(fidl::Error::NotNullable),
5985 Some(len) => len,
5986 };
5987 if len == 0 {
5989 return Ok(());
5990 };
5991 depth.increment()?;
5992 let envelope_size = 8;
5993 let bytes_len = len * envelope_size;
5994 let offset = decoder.out_of_line_offset(bytes_len)?;
5995 let mut _next_ordinal_to_read = 0;
5997 let mut next_offset = offset;
5998 let end_offset = offset + bytes_len;
5999 _next_ordinal_to_read += 1;
6000 if next_offset >= end_offset {
6001 return Ok(());
6002 }
6003
6004 while _next_ordinal_to_read < 1 {
6006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6007 _next_ordinal_to_read += 1;
6008 next_offset += envelope_size;
6009 }
6010
6011 let next_out_of_line = decoder.next_out_of_line();
6012 let handles_before = decoder.remaining_handles();
6013 if let Some((inlined, num_bytes, num_handles)) =
6014 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6015 {
6016 let member_inline_size =
6017 <TypeSpecificElementState as fidl::encoding::TypeMarker>::inline_size(
6018 decoder.context,
6019 );
6020 if inlined != (member_inline_size <= 4) {
6021 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6022 }
6023 let inner_offset;
6024 let mut inner_depth = depth.clone();
6025 if inlined {
6026 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6027 inner_offset = next_offset;
6028 } else {
6029 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6030 inner_depth.increment()?;
6031 }
6032 let val_ref = self
6033 .type_specific
6034 .get_or_insert_with(|| fidl::new_empty!(TypeSpecificElementState, D));
6035 fidl::decode!(
6036 TypeSpecificElementState,
6037 D,
6038 val_ref,
6039 decoder,
6040 inner_offset,
6041 inner_depth
6042 )?;
6043 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6044 {
6045 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6046 }
6047 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6048 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6049 }
6050 }
6051
6052 next_offset += envelope_size;
6053 _next_ordinal_to_read += 1;
6054 if next_offset >= end_offset {
6055 return Ok(());
6056 }
6057
6058 while _next_ordinal_to_read < 2 {
6060 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6061 _next_ordinal_to_read += 1;
6062 next_offset += envelope_size;
6063 }
6064
6065 let next_out_of_line = decoder.next_out_of_line();
6066 let handles_before = decoder.remaining_handles();
6067 if let Some((inlined, num_bytes, num_handles)) =
6068 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6069 {
6070 let member_inline_size =
6071 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6072 if inlined != (member_inline_size <= 4) {
6073 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6074 }
6075 let inner_offset;
6076 let mut inner_depth = depth.clone();
6077 if inlined {
6078 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6079 inner_offset = next_offset;
6080 } else {
6081 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6082 inner_depth.increment()?;
6083 }
6084 let val_ref = self.enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
6085 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6086 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6087 {
6088 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6089 }
6090 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6091 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6092 }
6093 }
6094
6095 next_offset += envelope_size;
6096 _next_ordinal_to_read += 1;
6097 if next_offset >= end_offset {
6098 return Ok(());
6099 }
6100
6101 while _next_ordinal_to_read < 3 {
6103 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6104 _next_ordinal_to_read += 1;
6105 next_offset += envelope_size;
6106 }
6107
6108 let next_out_of_line = decoder.next_out_of_line();
6109 let handles_before = decoder.remaining_handles();
6110 if let Some((inlined, num_bytes, num_handles)) =
6111 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6112 {
6113 let member_inline_size =
6114 <Latency as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6115 if inlined != (member_inline_size <= 4) {
6116 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6117 }
6118 let inner_offset;
6119 let mut inner_depth = depth.clone();
6120 if inlined {
6121 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6122 inner_offset = next_offset;
6123 } else {
6124 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6125 inner_depth.increment()?;
6126 }
6127 let val_ref = self.latency.get_or_insert_with(|| fidl::new_empty!(Latency, D));
6128 fidl::decode!(Latency, D, val_ref, decoder, inner_offset, inner_depth)?;
6129 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6130 {
6131 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6132 }
6133 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6134 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6135 }
6136 }
6137
6138 next_offset += envelope_size;
6139 _next_ordinal_to_read += 1;
6140 if next_offset >= end_offset {
6141 return Ok(());
6142 }
6143
6144 while _next_ordinal_to_read < 4 {
6146 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6147 _next_ordinal_to_read += 1;
6148 next_offset += envelope_size;
6149 }
6150
6151 let next_out_of_line = decoder.next_out_of_line();
6152 let handles_before = decoder.remaining_handles();
6153 if let Some((inlined, num_bytes, num_handles)) =
6154 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6155 {
6156 let member_inline_size =
6157 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::TypeMarker>::inline_size(
6158 decoder.context,
6159 );
6160 if inlined != (member_inline_size <= 4) {
6161 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6162 }
6163 let inner_offset;
6164 let mut inner_depth = depth.clone();
6165 if inlined {
6166 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6167 inner_offset = next_offset;
6168 } else {
6169 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6170 inner_depth.increment()?;
6171 }
6172 let val_ref = self
6173 .vendor_specific_data
6174 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D));
6175 fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
6176 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6177 {
6178 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6179 }
6180 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6181 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6182 }
6183 }
6184
6185 next_offset += envelope_size;
6186 _next_ordinal_to_read += 1;
6187 if next_offset >= end_offset {
6188 return Ok(());
6189 }
6190
6191 while _next_ordinal_to_read < 5 {
6193 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6194 _next_ordinal_to_read += 1;
6195 next_offset += envelope_size;
6196 }
6197
6198 let next_out_of_line = decoder.next_out_of_line();
6199 let handles_before = decoder.remaining_handles();
6200 if let Some((inlined, num_bytes, num_handles)) =
6201 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6202 {
6203 let member_inline_size =
6204 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6205 if inlined != (member_inline_size <= 4) {
6206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6207 }
6208 let inner_offset;
6209 let mut inner_depth = depth.clone();
6210 if inlined {
6211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6212 inner_offset = next_offset;
6213 } else {
6214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6215 inner_depth.increment()?;
6216 }
6217 let val_ref = self.started.get_or_insert_with(|| fidl::new_empty!(bool, D));
6218 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6220 {
6221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6222 }
6223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6225 }
6226 }
6227
6228 next_offset += envelope_size;
6229 _next_ordinal_to_read += 1;
6230 if next_offset >= end_offset {
6231 return Ok(());
6232 }
6233
6234 while _next_ordinal_to_read < 6 {
6236 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6237 _next_ordinal_to_read += 1;
6238 next_offset += envelope_size;
6239 }
6240
6241 let next_out_of_line = decoder.next_out_of_line();
6242 let handles_before = decoder.remaining_handles();
6243 if let Some((inlined, num_bytes, num_handles)) =
6244 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6245 {
6246 let member_inline_size =
6247 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6248 if inlined != (member_inline_size <= 4) {
6249 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6250 }
6251 let inner_offset;
6252 let mut inner_depth = depth.clone();
6253 if inlined {
6254 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6255 inner_offset = next_offset;
6256 } else {
6257 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6258 inner_depth.increment()?;
6259 }
6260 let val_ref = self.bypassed.get_or_insert_with(|| fidl::new_empty!(bool, D));
6261 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6262 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6263 {
6264 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6265 }
6266 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6267 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6268 }
6269 }
6270
6271 next_offset += envelope_size;
6272 _next_ordinal_to_read += 1;
6273 if next_offset >= end_offset {
6274 return Ok(());
6275 }
6276
6277 while _next_ordinal_to_read < 7 {
6279 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6280 _next_ordinal_to_read += 1;
6281 next_offset += envelope_size;
6282 }
6283
6284 let next_out_of_line = decoder.next_out_of_line();
6285 let handles_before = decoder.remaining_handles();
6286 if let Some((inlined, num_bytes, num_handles)) =
6287 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6288 {
6289 let member_inline_size =
6290 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6291 if inlined != (member_inline_size <= 4) {
6292 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6293 }
6294 let inner_offset;
6295 let mut inner_depth = depth.clone();
6296 if inlined {
6297 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6298 inner_offset = next_offset;
6299 } else {
6300 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6301 inner_depth.increment()?;
6302 }
6303 let val_ref = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6304 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6305 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6306 {
6307 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6308 }
6309 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6310 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6311 }
6312 }
6313
6314 next_offset += envelope_size;
6315 _next_ordinal_to_read += 1;
6316 if next_offset >= end_offset {
6317 return Ok(());
6318 }
6319
6320 while _next_ordinal_to_read < 8 {
6322 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6323 _next_ordinal_to_read += 1;
6324 next_offset += envelope_size;
6325 }
6326
6327 let next_out_of_line = decoder.next_out_of_line();
6328 let handles_before = decoder.remaining_handles();
6329 if let Some((inlined, num_bytes, num_handles)) =
6330 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6331 {
6332 let member_inline_size =
6333 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6334 if inlined != (member_inline_size <= 4) {
6335 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6336 }
6337 let inner_offset;
6338 let mut inner_depth = depth.clone();
6339 if inlined {
6340 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6341 inner_offset = next_offset;
6342 } else {
6343 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6344 inner_depth.increment()?;
6345 }
6346 let val_ref = self.turn_off_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6347 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6348 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6349 {
6350 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6351 }
6352 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6353 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6354 }
6355 }
6356
6357 next_offset += envelope_size;
6358 _next_ordinal_to_read += 1;
6359 if next_offset >= end_offset {
6360 return Ok(());
6361 }
6362
6363 while _next_ordinal_to_read < 9 {
6365 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6366 _next_ordinal_to_read += 1;
6367 next_offset += envelope_size;
6368 }
6369
6370 let next_out_of_line = decoder.next_out_of_line();
6371 let handles_before = decoder.remaining_handles();
6372 if let Some((inlined, num_bytes, num_handles)) =
6373 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6374 {
6375 let member_inline_size =
6376 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6377 if inlined != (member_inline_size <= 4) {
6378 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6379 }
6380 let inner_offset;
6381 let mut inner_depth = depth.clone();
6382 if inlined {
6383 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6384 inner_offset = next_offset;
6385 } else {
6386 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6387 inner_depth.increment()?;
6388 }
6389 let val_ref = self.processing_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6390 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6391 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6392 {
6393 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6394 }
6395 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6396 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6397 }
6398 }
6399
6400 next_offset += envelope_size;
6401
6402 while next_offset < end_offset {
6404 _next_ordinal_to_read += 1;
6405 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6406 next_offset += envelope_size;
6407 }
6408
6409 Ok(())
6410 }
6411 }
6412
6413 impl Endpoint {
6414 #[inline(always)]
6415 fn max_ordinal_present(&self) -> u64 {
6416 if let Some(_) = self.plug_detect_capabilities {
6417 return 2;
6418 }
6419 if let Some(_) = self.type_ {
6420 return 1;
6421 }
6422 0
6423 }
6424 }
6425
6426 impl fidl::encoding::ValueTypeMarker for Endpoint {
6427 type Borrowed<'a> = &'a Self;
6428 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6429 value
6430 }
6431 }
6432
6433 unsafe impl fidl::encoding::TypeMarker for Endpoint {
6434 type Owned = Self;
6435
6436 #[inline(always)]
6437 fn inline_align(_context: fidl::encoding::Context) -> usize {
6438 8
6439 }
6440
6441 #[inline(always)]
6442 fn inline_size(_context: fidl::encoding::Context) -> usize {
6443 16
6444 }
6445 }
6446
6447 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Endpoint, D> for &Endpoint {
6448 unsafe fn encode(
6449 self,
6450 encoder: &mut fidl::encoding::Encoder<'_, D>,
6451 offset: usize,
6452 mut depth: fidl::encoding::Depth,
6453 ) -> fidl::Result<()> {
6454 encoder.debug_check_bounds::<Endpoint>(offset);
6455 let max_ordinal: u64 = self.max_ordinal_present();
6457 encoder.write_num(max_ordinal, offset);
6458 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6459 if max_ordinal == 0 {
6461 return Ok(());
6462 }
6463 depth.increment()?;
6464 let envelope_size = 8;
6465 let bytes_len = max_ordinal as usize * envelope_size;
6466 #[allow(unused_variables)]
6467 let offset = encoder.out_of_line_offset(bytes_len);
6468 let mut _prev_end_offset: usize = 0;
6469 if 1 > max_ordinal {
6470 return Ok(());
6471 }
6472
6473 let cur_offset: usize = (1 - 1) * envelope_size;
6476
6477 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6479
6480 fidl::encoding::encode_in_envelope_optional::<EndpointType, D>(
6485 self.type_.as_ref().map(<EndpointType as fidl::encoding::ValueTypeMarker>::borrow),
6486 encoder,
6487 offset + cur_offset,
6488 depth,
6489 )?;
6490
6491 _prev_end_offset = cur_offset + envelope_size;
6492 if 2 > max_ordinal {
6493 return Ok(());
6494 }
6495
6496 let cur_offset: usize = (2 - 1) * envelope_size;
6499
6500 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6502
6503 fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
6508 self.plug_detect_capabilities
6509 .as_ref()
6510 .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
6511 encoder,
6512 offset + cur_offset,
6513 depth,
6514 )?;
6515
6516 _prev_end_offset = cur_offset + envelope_size;
6517
6518 Ok(())
6519 }
6520 }
6521
6522 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Endpoint {
6523 #[inline(always)]
6524 fn new_empty() -> Self {
6525 Self::default()
6526 }
6527
6528 unsafe fn decode(
6529 &mut self,
6530 decoder: &mut fidl::encoding::Decoder<'_, D>,
6531 offset: usize,
6532 mut depth: fidl::encoding::Depth,
6533 ) -> fidl::Result<()> {
6534 decoder.debug_check_bounds::<Self>(offset);
6535 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6536 None => return Err(fidl::Error::NotNullable),
6537 Some(len) => len,
6538 };
6539 if len == 0 {
6541 return Ok(());
6542 };
6543 depth.increment()?;
6544 let envelope_size = 8;
6545 let bytes_len = len * envelope_size;
6546 let offset = decoder.out_of_line_offset(bytes_len)?;
6547 let mut _next_ordinal_to_read = 0;
6549 let mut next_offset = offset;
6550 let end_offset = offset + bytes_len;
6551 _next_ordinal_to_read += 1;
6552 if next_offset >= end_offset {
6553 return Ok(());
6554 }
6555
6556 while _next_ordinal_to_read < 1 {
6558 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6559 _next_ordinal_to_read += 1;
6560 next_offset += envelope_size;
6561 }
6562
6563 let next_out_of_line = decoder.next_out_of_line();
6564 let handles_before = decoder.remaining_handles();
6565 if let Some((inlined, num_bytes, num_handles)) =
6566 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6567 {
6568 let member_inline_size =
6569 <EndpointType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6570 if inlined != (member_inline_size <= 4) {
6571 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6572 }
6573 let inner_offset;
6574 let mut inner_depth = depth.clone();
6575 if inlined {
6576 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6577 inner_offset = next_offset;
6578 } else {
6579 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6580 inner_depth.increment()?;
6581 }
6582 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(EndpointType, D));
6583 fidl::decode!(EndpointType, D, val_ref, decoder, inner_offset, inner_depth)?;
6584 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6585 {
6586 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6587 }
6588 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6589 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6590 }
6591 }
6592
6593 next_offset += envelope_size;
6594 _next_ordinal_to_read += 1;
6595 if next_offset >= end_offset {
6596 return Ok(());
6597 }
6598
6599 while _next_ordinal_to_read < 2 {
6601 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6602 _next_ordinal_to_read += 1;
6603 next_offset += envelope_size;
6604 }
6605
6606 let next_out_of_line = decoder.next_out_of_line();
6607 let handles_before = decoder.remaining_handles();
6608 if let Some((inlined, num_bytes, num_handles)) =
6609 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6610 {
6611 let member_inline_size =
6612 <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6613 decoder.context,
6614 );
6615 if inlined != (member_inline_size <= 4) {
6616 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6617 }
6618 let inner_offset;
6619 let mut inner_depth = depth.clone();
6620 if inlined {
6621 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6622 inner_offset = next_offset;
6623 } else {
6624 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6625 inner_depth.increment()?;
6626 }
6627 let val_ref = self
6628 .plug_detect_capabilities
6629 .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6630 fidl::decode!(
6631 PlugDetectCapabilities,
6632 D,
6633 val_ref,
6634 decoder,
6635 inner_offset,
6636 inner_depth
6637 )?;
6638 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6639 {
6640 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6641 }
6642 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6643 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6644 }
6645 }
6646
6647 next_offset += envelope_size;
6648
6649 while next_offset < end_offset {
6651 _next_ordinal_to_read += 1;
6652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6653 next_offset += envelope_size;
6654 }
6655
6656 Ok(())
6657 }
6658 }
6659
6660 impl EndpointElementState {
6661 #[inline(always)]
6662 fn max_ordinal_present(&self) -> u64 {
6663 if let Some(_) = self.plug_state {
6664 return 1;
6665 }
6666 0
6667 }
6668 }
6669
6670 impl fidl::encoding::ValueTypeMarker for EndpointElementState {
6671 type Borrowed<'a> = &'a Self;
6672 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6673 value
6674 }
6675 }
6676
6677 unsafe impl fidl::encoding::TypeMarker for EndpointElementState {
6678 type Owned = Self;
6679
6680 #[inline(always)]
6681 fn inline_align(_context: fidl::encoding::Context) -> usize {
6682 8
6683 }
6684
6685 #[inline(always)]
6686 fn inline_size(_context: fidl::encoding::Context) -> usize {
6687 16
6688 }
6689 }
6690
6691 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EndpointElementState, D>
6692 for &EndpointElementState
6693 {
6694 unsafe fn encode(
6695 self,
6696 encoder: &mut fidl::encoding::Encoder<'_, D>,
6697 offset: usize,
6698 mut depth: fidl::encoding::Depth,
6699 ) -> fidl::Result<()> {
6700 encoder.debug_check_bounds::<EndpointElementState>(offset);
6701 let max_ordinal: u64 = self.max_ordinal_present();
6703 encoder.write_num(max_ordinal, offset);
6704 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6705 if max_ordinal == 0 {
6707 return Ok(());
6708 }
6709 depth.increment()?;
6710 let envelope_size = 8;
6711 let bytes_len = max_ordinal as usize * envelope_size;
6712 #[allow(unused_variables)]
6713 let offset = encoder.out_of_line_offset(bytes_len);
6714 let mut _prev_end_offset: usize = 0;
6715 if 1 > max_ordinal {
6716 return Ok(());
6717 }
6718
6719 let cur_offset: usize = (1 - 1) * envelope_size;
6722
6723 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6725
6726 fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6731 self.plug_state
6732 .as_ref()
6733 .map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6734 encoder,
6735 offset + cur_offset,
6736 depth,
6737 )?;
6738
6739 _prev_end_offset = cur_offset + envelope_size;
6740
6741 Ok(())
6742 }
6743 }
6744
6745 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EndpointElementState {
6746 #[inline(always)]
6747 fn new_empty() -> Self {
6748 Self::default()
6749 }
6750
6751 unsafe fn decode(
6752 &mut self,
6753 decoder: &mut fidl::encoding::Decoder<'_, D>,
6754 offset: usize,
6755 mut depth: fidl::encoding::Depth,
6756 ) -> fidl::Result<()> {
6757 decoder.debug_check_bounds::<Self>(offset);
6758 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6759 None => return Err(fidl::Error::NotNullable),
6760 Some(len) => len,
6761 };
6762 if len == 0 {
6764 return Ok(());
6765 };
6766 depth.increment()?;
6767 let envelope_size = 8;
6768 let bytes_len = len * envelope_size;
6769 let offset = decoder.out_of_line_offset(bytes_len)?;
6770 let mut _next_ordinal_to_read = 0;
6772 let mut next_offset = offset;
6773 let end_offset = offset + bytes_len;
6774 _next_ordinal_to_read += 1;
6775 if next_offset >= end_offset {
6776 return Ok(());
6777 }
6778
6779 while _next_ordinal_to_read < 1 {
6781 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6782 _next_ordinal_to_read += 1;
6783 next_offset += envelope_size;
6784 }
6785
6786 let next_out_of_line = decoder.next_out_of_line();
6787 let handles_before = decoder.remaining_handles();
6788 if let Some((inlined, num_bytes, num_handles)) =
6789 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6790 {
6791 let member_inline_size =
6792 <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6793 if inlined != (member_inline_size <= 4) {
6794 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6795 }
6796 let inner_offset;
6797 let mut inner_depth = depth.clone();
6798 if inlined {
6799 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6800 inner_offset = next_offset;
6801 } else {
6802 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6803 inner_depth.increment()?;
6804 }
6805 let val_ref = self.plug_state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6806 fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6807 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6808 {
6809 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6810 }
6811 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6812 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6813 }
6814 }
6815
6816 next_offset += envelope_size;
6817
6818 while next_offset < end_offset {
6820 _next_ordinal_to_read += 1;
6821 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6822 next_offset += envelope_size;
6823 }
6824
6825 Ok(())
6826 }
6827 }
6828
6829 impl Equalizer {
6830 #[inline(always)]
6831 fn max_ordinal_present(&self) -> u64 {
6832 if let Some(_) = self.max_gain_db {
6833 return 8;
6834 }
6835 if let Some(_) = self.min_gain_db {
6836 return 7;
6837 }
6838 if let Some(_) = self.max_q {
6839 return 6;
6840 }
6841 if let Some(_) = self.max_frequency {
6842 return 5;
6843 }
6844 if let Some(_) = self.min_frequency {
6845 return 4;
6846 }
6847 if let Some(_) = self.can_disable_bands {
6848 return 3;
6849 }
6850 if let Some(_) = self.supported_controls {
6851 return 2;
6852 }
6853 if let Some(_) = self.bands {
6854 return 1;
6855 }
6856 0
6857 }
6858 }
6859
6860 impl fidl::encoding::ValueTypeMarker for Equalizer {
6861 type Borrowed<'a> = &'a Self;
6862 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6863 value
6864 }
6865 }
6866
6867 unsafe impl fidl::encoding::TypeMarker for Equalizer {
6868 type Owned = Self;
6869
6870 #[inline(always)]
6871 fn inline_align(_context: fidl::encoding::Context) -> usize {
6872 8
6873 }
6874
6875 #[inline(always)]
6876 fn inline_size(_context: fidl::encoding::Context) -> usize {
6877 16
6878 }
6879 }
6880
6881 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Equalizer, D>
6882 for &Equalizer
6883 {
6884 unsafe fn encode(
6885 self,
6886 encoder: &mut fidl::encoding::Encoder<'_, D>,
6887 offset: usize,
6888 mut depth: fidl::encoding::Depth,
6889 ) -> fidl::Result<()> {
6890 encoder.debug_check_bounds::<Equalizer>(offset);
6891 let max_ordinal: u64 = self.max_ordinal_present();
6893 encoder.write_num(max_ordinal, offset);
6894 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6895 if max_ordinal == 0 {
6897 return Ok(());
6898 }
6899 depth.increment()?;
6900 let envelope_size = 8;
6901 let bytes_len = max_ordinal as usize * envelope_size;
6902 #[allow(unused_variables)]
6903 let offset = encoder.out_of_line_offset(bytes_len);
6904 let mut _prev_end_offset: usize = 0;
6905 if 1 > max_ordinal {
6906 return Ok(());
6907 }
6908
6909 let cur_offset: usize = (1 - 1) * envelope_size;
6912
6913 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6915
6916 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBand, 64>, D>(
6921 self.bands.as_ref().map(<fidl::encoding::Vector<EqualizerBand, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6922 encoder, offset + cur_offset, depth
6923 )?;
6924
6925 _prev_end_offset = cur_offset + envelope_size;
6926 if 2 > max_ordinal {
6927 return Ok(());
6928 }
6929
6930 let cur_offset: usize = (2 - 1) * envelope_size;
6933
6934 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6936
6937 fidl::encoding::encode_in_envelope_optional::<EqualizerSupportedControls, D>(
6942 self.supported_controls
6943 .as_ref()
6944 .map(<EqualizerSupportedControls as fidl::encoding::ValueTypeMarker>::borrow),
6945 encoder,
6946 offset + cur_offset,
6947 depth,
6948 )?;
6949
6950 _prev_end_offset = cur_offset + envelope_size;
6951 if 3 > max_ordinal {
6952 return Ok(());
6953 }
6954
6955 let cur_offset: usize = (3 - 1) * envelope_size;
6958
6959 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6961
6962 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6967 self.can_disable_bands
6968 .as_ref()
6969 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6970 encoder,
6971 offset + cur_offset,
6972 depth,
6973 )?;
6974
6975 _prev_end_offset = cur_offset + envelope_size;
6976 if 4 > max_ordinal {
6977 return Ok(());
6978 }
6979
6980 let cur_offset: usize = (4 - 1) * envelope_size;
6983
6984 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6986
6987 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6992 self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6993 encoder,
6994 offset + cur_offset,
6995 depth,
6996 )?;
6997
6998 _prev_end_offset = cur_offset + envelope_size;
6999 if 5 > max_ordinal {
7000 return Ok(());
7001 }
7002
7003 let cur_offset: usize = (5 - 1) * envelope_size;
7006
7007 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7009
7010 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7015 self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7016 encoder,
7017 offset + cur_offset,
7018 depth,
7019 )?;
7020
7021 _prev_end_offset = cur_offset + envelope_size;
7022 if 6 > max_ordinal {
7023 return Ok(());
7024 }
7025
7026 let cur_offset: usize = (6 - 1) * envelope_size;
7029
7030 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7032
7033 fidl::encoding::encode_in_envelope_optional::<f32, D>(
7038 self.max_q.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7039 encoder,
7040 offset + cur_offset,
7041 depth,
7042 )?;
7043
7044 _prev_end_offset = cur_offset + envelope_size;
7045 if 7 > max_ordinal {
7046 return Ok(());
7047 }
7048
7049 let cur_offset: usize = (7 - 1) * envelope_size;
7052
7053 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7055
7056 fidl::encoding::encode_in_envelope_optional::<f32, D>(
7061 self.min_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7062 encoder,
7063 offset + cur_offset,
7064 depth,
7065 )?;
7066
7067 _prev_end_offset = cur_offset + envelope_size;
7068 if 8 > max_ordinal {
7069 return Ok(());
7070 }
7071
7072 let cur_offset: usize = (8 - 1) * envelope_size;
7075
7076 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7078
7079 fidl::encoding::encode_in_envelope_optional::<f32, D>(
7084 self.max_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7085 encoder,
7086 offset + cur_offset,
7087 depth,
7088 )?;
7089
7090 _prev_end_offset = cur_offset + envelope_size;
7091
7092 Ok(())
7093 }
7094 }
7095
7096 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Equalizer {
7097 #[inline(always)]
7098 fn new_empty() -> Self {
7099 Self::default()
7100 }
7101
7102 unsafe fn decode(
7103 &mut self,
7104 decoder: &mut fidl::encoding::Decoder<'_, D>,
7105 offset: usize,
7106 mut depth: fidl::encoding::Depth,
7107 ) -> fidl::Result<()> {
7108 decoder.debug_check_bounds::<Self>(offset);
7109 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7110 None => return Err(fidl::Error::NotNullable),
7111 Some(len) => len,
7112 };
7113 if len == 0 {
7115 return Ok(());
7116 };
7117 depth.increment()?;
7118 let envelope_size = 8;
7119 let bytes_len = len * envelope_size;
7120 let offset = decoder.out_of_line_offset(bytes_len)?;
7121 let mut _next_ordinal_to_read = 0;
7123 let mut next_offset = offset;
7124 let end_offset = offset + bytes_len;
7125 _next_ordinal_to_read += 1;
7126 if next_offset >= end_offset {
7127 return Ok(());
7128 }
7129
7130 while _next_ordinal_to_read < 1 {
7132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7133 _next_ordinal_to_read += 1;
7134 next_offset += envelope_size;
7135 }
7136
7137 let next_out_of_line = decoder.next_out_of_line();
7138 let handles_before = decoder.remaining_handles();
7139 if let Some((inlined, num_bytes, num_handles)) =
7140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7141 {
7142 let member_inline_size = <fidl::encoding::Vector<EqualizerBand, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7143 if inlined != (member_inline_size <= 4) {
7144 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7145 }
7146 let inner_offset;
7147 let mut inner_depth = depth.clone();
7148 if inlined {
7149 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7150 inner_offset = next_offset;
7151 } else {
7152 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7153 inner_depth.increment()?;
7154 }
7155 let val_ref = self.bands.get_or_insert_with(
7156 || fidl::new_empty!(fidl::encoding::Vector<EqualizerBand, 64>, D),
7157 );
7158 fidl::decode!(fidl::encoding::Vector<EqualizerBand, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
7159 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7160 {
7161 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7162 }
7163 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7164 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7165 }
7166 }
7167
7168 next_offset += envelope_size;
7169 _next_ordinal_to_read += 1;
7170 if next_offset >= end_offset {
7171 return Ok(());
7172 }
7173
7174 while _next_ordinal_to_read < 2 {
7176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7177 _next_ordinal_to_read += 1;
7178 next_offset += envelope_size;
7179 }
7180
7181 let next_out_of_line = decoder.next_out_of_line();
7182 let handles_before = decoder.remaining_handles();
7183 if let Some((inlined, num_bytes, num_handles)) =
7184 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7185 {
7186 let member_inline_size =
7187 <EqualizerSupportedControls as fidl::encoding::TypeMarker>::inline_size(
7188 decoder.context,
7189 );
7190 if inlined != (member_inline_size <= 4) {
7191 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7192 }
7193 let inner_offset;
7194 let mut inner_depth = depth.clone();
7195 if inlined {
7196 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7197 inner_offset = next_offset;
7198 } else {
7199 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7200 inner_depth.increment()?;
7201 }
7202 let val_ref = self
7203 .supported_controls
7204 .get_or_insert_with(|| fidl::new_empty!(EqualizerSupportedControls, D));
7205 fidl::decode!(
7206 EqualizerSupportedControls,
7207 D,
7208 val_ref,
7209 decoder,
7210 inner_offset,
7211 inner_depth
7212 )?;
7213 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7214 {
7215 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7216 }
7217 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7218 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7219 }
7220 }
7221
7222 next_offset += envelope_size;
7223 _next_ordinal_to_read += 1;
7224 if next_offset >= end_offset {
7225 return Ok(());
7226 }
7227
7228 while _next_ordinal_to_read < 3 {
7230 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7231 _next_ordinal_to_read += 1;
7232 next_offset += envelope_size;
7233 }
7234
7235 let next_out_of_line = decoder.next_out_of_line();
7236 let handles_before = decoder.remaining_handles();
7237 if let Some((inlined, num_bytes, num_handles)) =
7238 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7239 {
7240 let member_inline_size =
7241 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7242 if inlined != (member_inline_size <= 4) {
7243 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7244 }
7245 let inner_offset;
7246 let mut inner_depth = depth.clone();
7247 if inlined {
7248 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7249 inner_offset = next_offset;
7250 } else {
7251 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7252 inner_depth.increment()?;
7253 }
7254 let val_ref =
7255 self.can_disable_bands.get_or_insert_with(|| fidl::new_empty!(bool, D));
7256 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7257 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7258 {
7259 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7260 }
7261 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7262 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7263 }
7264 }
7265
7266 next_offset += envelope_size;
7267 _next_ordinal_to_read += 1;
7268 if next_offset >= end_offset {
7269 return Ok(());
7270 }
7271
7272 while _next_ordinal_to_read < 4 {
7274 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7275 _next_ordinal_to_read += 1;
7276 next_offset += envelope_size;
7277 }
7278
7279 let next_out_of_line = decoder.next_out_of_line();
7280 let handles_before = decoder.remaining_handles();
7281 if let Some((inlined, num_bytes, num_handles)) =
7282 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7283 {
7284 let member_inline_size =
7285 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7286 if inlined != (member_inline_size <= 4) {
7287 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7288 }
7289 let inner_offset;
7290 let mut inner_depth = depth.clone();
7291 if inlined {
7292 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7293 inner_offset = next_offset;
7294 } else {
7295 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7296 inner_depth.increment()?;
7297 }
7298 let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
7299 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7300 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7301 {
7302 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7303 }
7304 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7305 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7306 }
7307 }
7308
7309 next_offset += envelope_size;
7310 _next_ordinal_to_read += 1;
7311 if next_offset >= end_offset {
7312 return Ok(());
7313 }
7314
7315 while _next_ordinal_to_read < 5 {
7317 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7318 _next_ordinal_to_read += 1;
7319 next_offset += envelope_size;
7320 }
7321
7322 let next_out_of_line = decoder.next_out_of_line();
7323 let handles_before = decoder.remaining_handles();
7324 if let Some((inlined, num_bytes, num_handles)) =
7325 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7326 {
7327 let member_inline_size =
7328 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7329 if inlined != (member_inline_size <= 4) {
7330 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7331 }
7332 let inner_offset;
7333 let mut inner_depth = depth.clone();
7334 if inlined {
7335 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7336 inner_offset = next_offset;
7337 } else {
7338 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7339 inner_depth.increment()?;
7340 }
7341 let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
7342 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7343 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7344 {
7345 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7346 }
7347 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7348 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7349 }
7350 }
7351
7352 next_offset += envelope_size;
7353 _next_ordinal_to_read += 1;
7354 if next_offset >= end_offset {
7355 return Ok(());
7356 }
7357
7358 while _next_ordinal_to_read < 6 {
7360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7361 _next_ordinal_to_read += 1;
7362 next_offset += envelope_size;
7363 }
7364
7365 let next_out_of_line = decoder.next_out_of_line();
7366 let handles_before = decoder.remaining_handles();
7367 if let Some((inlined, num_bytes, num_handles)) =
7368 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7369 {
7370 let member_inline_size =
7371 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7372 if inlined != (member_inline_size <= 4) {
7373 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7374 }
7375 let inner_offset;
7376 let mut inner_depth = depth.clone();
7377 if inlined {
7378 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7379 inner_offset = next_offset;
7380 } else {
7381 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7382 inner_depth.increment()?;
7383 }
7384 let val_ref = self.max_q.get_or_insert_with(|| fidl::new_empty!(f32, D));
7385 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7386 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7387 {
7388 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7389 }
7390 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7391 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7392 }
7393 }
7394
7395 next_offset += envelope_size;
7396 _next_ordinal_to_read += 1;
7397 if next_offset >= end_offset {
7398 return Ok(());
7399 }
7400
7401 while _next_ordinal_to_read < 7 {
7403 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7404 _next_ordinal_to_read += 1;
7405 next_offset += envelope_size;
7406 }
7407
7408 let next_out_of_line = decoder.next_out_of_line();
7409 let handles_before = decoder.remaining_handles();
7410 if let Some((inlined, num_bytes, num_handles)) =
7411 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7412 {
7413 let member_inline_size =
7414 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7415 if inlined != (member_inline_size <= 4) {
7416 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7417 }
7418 let inner_offset;
7419 let mut inner_depth = depth.clone();
7420 if inlined {
7421 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7422 inner_offset = next_offset;
7423 } else {
7424 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7425 inner_depth.increment()?;
7426 }
7427 let val_ref = self.min_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
7428 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7430 {
7431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7432 }
7433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7435 }
7436 }
7437
7438 next_offset += envelope_size;
7439 _next_ordinal_to_read += 1;
7440 if next_offset >= end_offset {
7441 return Ok(());
7442 }
7443
7444 while _next_ordinal_to_read < 8 {
7446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7447 _next_ordinal_to_read += 1;
7448 next_offset += envelope_size;
7449 }
7450
7451 let next_out_of_line = decoder.next_out_of_line();
7452 let handles_before = decoder.remaining_handles();
7453 if let Some((inlined, num_bytes, num_handles)) =
7454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7455 {
7456 let member_inline_size =
7457 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7458 if inlined != (member_inline_size <= 4) {
7459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7460 }
7461 let inner_offset;
7462 let mut inner_depth = depth.clone();
7463 if inlined {
7464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7465 inner_offset = next_offset;
7466 } else {
7467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7468 inner_depth.increment()?;
7469 }
7470 let val_ref = self.max_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
7471 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7472 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7473 {
7474 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7475 }
7476 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7477 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7478 }
7479 }
7480
7481 next_offset += envelope_size;
7482
7483 while next_offset < end_offset {
7485 _next_ordinal_to_read += 1;
7486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7487 next_offset += envelope_size;
7488 }
7489
7490 Ok(())
7491 }
7492 }
7493
7494 impl EqualizerBand {
7495 #[inline(always)]
7496 fn max_ordinal_present(&self) -> u64 {
7497 if let Some(_) = self.id {
7498 return 1;
7499 }
7500 0
7501 }
7502 }
7503
7504 impl fidl::encoding::ValueTypeMarker for EqualizerBand {
7505 type Borrowed<'a> = &'a Self;
7506 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7507 value
7508 }
7509 }
7510
7511 unsafe impl fidl::encoding::TypeMarker for EqualizerBand {
7512 type Owned = Self;
7513
7514 #[inline(always)]
7515 fn inline_align(_context: fidl::encoding::Context) -> usize {
7516 8
7517 }
7518
7519 #[inline(always)]
7520 fn inline_size(_context: fidl::encoding::Context) -> usize {
7521 16
7522 }
7523 }
7524
7525 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerBand, D>
7526 for &EqualizerBand
7527 {
7528 unsafe fn encode(
7529 self,
7530 encoder: &mut fidl::encoding::Encoder<'_, D>,
7531 offset: usize,
7532 mut depth: fidl::encoding::Depth,
7533 ) -> fidl::Result<()> {
7534 encoder.debug_check_bounds::<EqualizerBand>(offset);
7535 let max_ordinal: u64 = self.max_ordinal_present();
7537 encoder.write_num(max_ordinal, offset);
7538 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7539 if max_ordinal == 0 {
7541 return Ok(());
7542 }
7543 depth.increment()?;
7544 let envelope_size = 8;
7545 let bytes_len = max_ordinal as usize * envelope_size;
7546 #[allow(unused_variables)]
7547 let offset = encoder.out_of_line_offset(bytes_len);
7548 let mut _prev_end_offset: usize = 0;
7549 if 1 > max_ordinal {
7550 return Ok(());
7551 }
7552
7553 let cur_offset: usize = (1 - 1) * envelope_size;
7556
7557 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7559
7560 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7565 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7566 encoder,
7567 offset + cur_offset,
7568 depth,
7569 )?;
7570
7571 _prev_end_offset = cur_offset + envelope_size;
7572
7573 Ok(())
7574 }
7575 }
7576
7577 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBand {
7578 #[inline(always)]
7579 fn new_empty() -> Self {
7580 Self::default()
7581 }
7582
7583 unsafe fn decode(
7584 &mut self,
7585 decoder: &mut fidl::encoding::Decoder<'_, D>,
7586 offset: usize,
7587 mut depth: fidl::encoding::Depth,
7588 ) -> fidl::Result<()> {
7589 decoder.debug_check_bounds::<Self>(offset);
7590 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7591 None => return Err(fidl::Error::NotNullable),
7592 Some(len) => len,
7593 };
7594 if len == 0 {
7596 return Ok(());
7597 };
7598 depth.increment()?;
7599 let envelope_size = 8;
7600 let bytes_len = len * envelope_size;
7601 let offset = decoder.out_of_line_offset(bytes_len)?;
7602 let mut _next_ordinal_to_read = 0;
7604 let mut next_offset = offset;
7605 let end_offset = offset + bytes_len;
7606 _next_ordinal_to_read += 1;
7607 if next_offset >= end_offset {
7608 return Ok(());
7609 }
7610
7611 while _next_ordinal_to_read < 1 {
7613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7614 _next_ordinal_to_read += 1;
7615 next_offset += envelope_size;
7616 }
7617
7618 let next_out_of_line = decoder.next_out_of_line();
7619 let handles_before = decoder.remaining_handles();
7620 if let Some((inlined, num_bytes, num_handles)) =
7621 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7622 {
7623 let member_inline_size =
7624 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7625 if inlined != (member_inline_size <= 4) {
7626 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7627 }
7628 let inner_offset;
7629 let mut inner_depth = depth.clone();
7630 if inlined {
7631 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7632 inner_offset = next_offset;
7633 } else {
7634 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7635 inner_depth.increment()?;
7636 }
7637 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7638 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7639 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7640 {
7641 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7642 }
7643 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7644 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7645 }
7646 }
7647
7648 next_offset += envelope_size;
7649
7650 while next_offset < end_offset {
7652 _next_ordinal_to_read += 1;
7653 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7654 next_offset += envelope_size;
7655 }
7656
7657 Ok(())
7658 }
7659 }
7660
7661 impl EqualizerBandState {
7662 #[inline(always)]
7663 fn max_ordinal_present(&self) -> u64 {
7664 if let Some(_) = self.enabled {
7665 return 6;
7666 }
7667 if let Some(_) = self.gain_db {
7668 return 5;
7669 }
7670 if let Some(_) = self.q {
7671 return 4;
7672 }
7673 if let Some(_) = self.frequency {
7674 return 3;
7675 }
7676 if let Some(_) = self.type_ {
7677 return 2;
7678 }
7679 if let Some(_) = self.id {
7680 return 1;
7681 }
7682 0
7683 }
7684 }
7685
7686 impl fidl::encoding::ValueTypeMarker for EqualizerBandState {
7687 type Borrowed<'a> = &'a Self;
7688 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7689 value
7690 }
7691 }
7692
7693 unsafe impl fidl::encoding::TypeMarker for EqualizerBandState {
7694 type Owned = Self;
7695
7696 #[inline(always)]
7697 fn inline_align(_context: fidl::encoding::Context) -> usize {
7698 8
7699 }
7700
7701 #[inline(always)]
7702 fn inline_size(_context: fidl::encoding::Context) -> usize {
7703 16
7704 }
7705 }
7706
7707 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerBandState, D>
7708 for &EqualizerBandState
7709 {
7710 unsafe fn encode(
7711 self,
7712 encoder: &mut fidl::encoding::Encoder<'_, D>,
7713 offset: usize,
7714 mut depth: fidl::encoding::Depth,
7715 ) -> fidl::Result<()> {
7716 encoder.debug_check_bounds::<EqualizerBandState>(offset);
7717 let max_ordinal: u64 = self.max_ordinal_present();
7719 encoder.write_num(max_ordinal, offset);
7720 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7721 if max_ordinal == 0 {
7723 return Ok(());
7724 }
7725 depth.increment()?;
7726 let envelope_size = 8;
7727 let bytes_len = max_ordinal as usize * envelope_size;
7728 #[allow(unused_variables)]
7729 let offset = encoder.out_of_line_offset(bytes_len);
7730 let mut _prev_end_offset: usize = 0;
7731 if 1 > max_ordinal {
7732 return Ok(());
7733 }
7734
7735 let cur_offset: usize = (1 - 1) * envelope_size;
7738
7739 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7741
7742 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7747 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7748 encoder,
7749 offset + cur_offset,
7750 depth,
7751 )?;
7752
7753 _prev_end_offset = cur_offset + envelope_size;
7754 if 2 > max_ordinal {
7755 return Ok(());
7756 }
7757
7758 let cur_offset: usize = (2 - 1) * envelope_size;
7761
7762 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7764
7765 fidl::encoding::encode_in_envelope_optional::<EqualizerBandType, D>(
7770 self.type_
7771 .as_ref()
7772 .map(<EqualizerBandType as fidl::encoding::ValueTypeMarker>::borrow),
7773 encoder,
7774 offset + cur_offset,
7775 depth,
7776 )?;
7777
7778 _prev_end_offset = cur_offset + envelope_size;
7779 if 3 > max_ordinal {
7780 return Ok(());
7781 }
7782
7783 let cur_offset: usize = (3 - 1) * envelope_size;
7786
7787 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7789
7790 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7795 self.frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7796 encoder,
7797 offset + cur_offset,
7798 depth,
7799 )?;
7800
7801 _prev_end_offset = cur_offset + envelope_size;
7802 if 4 > max_ordinal {
7803 return Ok(());
7804 }
7805
7806 let cur_offset: usize = (4 - 1) * envelope_size;
7809
7810 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7812
7813 fidl::encoding::encode_in_envelope_optional::<f32, D>(
7818 self.q.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7819 encoder,
7820 offset + cur_offset,
7821 depth,
7822 )?;
7823
7824 _prev_end_offset = cur_offset + envelope_size;
7825 if 5 > max_ordinal {
7826 return Ok(());
7827 }
7828
7829 let cur_offset: usize = (5 - 1) * envelope_size;
7832
7833 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7835
7836 fidl::encoding::encode_in_envelope_optional::<f32, D>(
7841 self.gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7842 encoder,
7843 offset + cur_offset,
7844 depth,
7845 )?;
7846
7847 _prev_end_offset = cur_offset + envelope_size;
7848 if 6 > max_ordinal {
7849 return Ok(());
7850 }
7851
7852 let cur_offset: usize = (6 - 1) * envelope_size;
7855
7856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7858
7859 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7864 self.enabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7865 encoder,
7866 offset + cur_offset,
7867 depth,
7868 )?;
7869
7870 _prev_end_offset = cur_offset + envelope_size;
7871
7872 Ok(())
7873 }
7874 }
7875
7876 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBandState {
7877 #[inline(always)]
7878 fn new_empty() -> Self {
7879 Self::default()
7880 }
7881
7882 unsafe fn decode(
7883 &mut self,
7884 decoder: &mut fidl::encoding::Decoder<'_, D>,
7885 offset: usize,
7886 mut depth: fidl::encoding::Depth,
7887 ) -> fidl::Result<()> {
7888 decoder.debug_check_bounds::<Self>(offset);
7889 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7890 None => return Err(fidl::Error::NotNullable),
7891 Some(len) => len,
7892 };
7893 if len == 0 {
7895 return Ok(());
7896 };
7897 depth.increment()?;
7898 let envelope_size = 8;
7899 let bytes_len = len * envelope_size;
7900 let offset = decoder.out_of_line_offset(bytes_len)?;
7901 let mut _next_ordinal_to_read = 0;
7903 let mut next_offset = offset;
7904 let end_offset = offset + bytes_len;
7905 _next_ordinal_to_read += 1;
7906 if next_offset >= end_offset {
7907 return Ok(());
7908 }
7909
7910 while _next_ordinal_to_read < 1 {
7912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7913 _next_ordinal_to_read += 1;
7914 next_offset += envelope_size;
7915 }
7916
7917 let next_out_of_line = decoder.next_out_of_line();
7918 let handles_before = decoder.remaining_handles();
7919 if let Some((inlined, num_bytes, num_handles)) =
7920 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7921 {
7922 let member_inline_size =
7923 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7924 if inlined != (member_inline_size <= 4) {
7925 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7926 }
7927 let inner_offset;
7928 let mut inner_depth = depth.clone();
7929 if inlined {
7930 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7931 inner_offset = next_offset;
7932 } else {
7933 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7934 inner_depth.increment()?;
7935 }
7936 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7937 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7938 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7939 {
7940 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7941 }
7942 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7943 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7944 }
7945 }
7946
7947 next_offset += envelope_size;
7948 _next_ordinal_to_read += 1;
7949 if next_offset >= end_offset {
7950 return Ok(());
7951 }
7952
7953 while _next_ordinal_to_read < 2 {
7955 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7956 _next_ordinal_to_read += 1;
7957 next_offset += envelope_size;
7958 }
7959
7960 let next_out_of_line = decoder.next_out_of_line();
7961 let handles_before = decoder.remaining_handles();
7962 if let Some((inlined, num_bytes, num_handles)) =
7963 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7964 {
7965 let member_inline_size =
7966 <EqualizerBandType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7967 if inlined != (member_inline_size <= 4) {
7968 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7969 }
7970 let inner_offset;
7971 let mut inner_depth = depth.clone();
7972 if inlined {
7973 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7974 inner_offset = next_offset;
7975 } else {
7976 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7977 inner_depth.increment()?;
7978 }
7979 let val_ref =
7980 self.type_.get_or_insert_with(|| fidl::new_empty!(EqualizerBandType, D));
7981 fidl::decode!(EqualizerBandType, D, val_ref, decoder, inner_offset, inner_depth)?;
7982 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7983 {
7984 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7985 }
7986 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7987 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7988 }
7989 }
7990
7991 next_offset += envelope_size;
7992 _next_ordinal_to_read += 1;
7993 if next_offset >= end_offset {
7994 return Ok(());
7995 }
7996
7997 while _next_ordinal_to_read < 3 {
7999 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8000 _next_ordinal_to_read += 1;
8001 next_offset += envelope_size;
8002 }
8003
8004 let next_out_of_line = decoder.next_out_of_line();
8005 let handles_before = decoder.remaining_handles();
8006 if let Some((inlined, num_bytes, num_handles)) =
8007 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8008 {
8009 let member_inline_size =
8010 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8011 if inlined != (member_inline_size <= 4) {
8012 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8013 }
8014 let inner_offset;
8015 let mut inner_depth = depth.clone();
8016 if inlined {
8017 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8018 inner_offset = next_offset;
8019 } else {
8020 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8021 inner_depth.increment()?;
8022 }
8023 let val_ref = self.frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
8024 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
8025 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8026 {
8027 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8028 }
8029 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8030 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8031 }
8032 }
8033
8034 next_offset += envelope_size;
8035 _next_ordinal_to_read += 1;
8036 if next_offset >= end_offset {
8037 return Ok(());
8038 }
8039
8040 while _next_ordinal_to_read < 4 {
8042 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8043 _next_ordinal_to_read += 1;
8044 next_offset += envelope_size;
8045 }
8046
8047 let next_out_of_line = decoder.next_out_of_line();
8048 let handles_before = decoder.remaining_handles();
8049 if let Some((inlined, num_bytes, num_handles)) =
8050 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8051 {
8052 let member_inline_size =
8053 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8054 if inlined != (member_inline_size <= 4) {
8055 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8056 }
8057 let inner_offset;
8058 let mut inner_depth = depth.clone();
8059 if inlined {
8060 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8061 inner_offset = next_offset;
8062 } else {
8063 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8064 inner_depth.increment()?;
8065 }
8066 let val_ref = self.q.get_or_insert_with(|| fidl::new_empty!(f32, D));
8067 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8068 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8069 {
8070 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8071 }
8072 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8073 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8074 }
8075 }
8076
8077 next_offset += envelope_size;
8078 _next_ordinal_to_read += 1;
8079 if next_offset >= end_offset {
8080 return Ok(());
8081 }
8082
8083 while _next_ordinal_to_read < 5 {
8085 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8086 _next_ordinal_to_read += 1;
8087 next_offset += envelope_size;
8088 }
8089
8090 let next_out_of_line = decoder.next_out_of_line();
8091 let handles_before = decoder.remaining_handles();
8092 if let Some((inlined, num_bytes, num_handles)) =
8093 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8094 {
8095 let member_inline_size =
8096 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8097 if inlined != (member_inline_size <= 4) {
8098 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8099 }
8100 let inner_offset;
8101 let mut inner_depth = depth.clone();
8102 if inlined {
8103 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8104 inner_offset = next_offset;
8105 } else {
8106 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8107 inner_depth.increment()?;
8108 }
8109 let val_ref = self.gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
8110 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8111 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8112 {
8113 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8114 }
8115 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8116 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8117 }
8118 }
8119
8120 next_offset += envelope_size;
8121 _next_ordinal_to_read += 1;
8122 if next_offset >= end_offset {
8123 return Ok(());
8124 }
8125
8126 while _next_ordinal_to_read < 6 {
8128 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8129 _next_ordinal_to_read += 1;
8130 next_offset += envelope_size;
8131 }
8132
8133 let next_out_of_line = decoder.next_out_of_line();
8134 let handles_before = decoder.remaining_handles();
8135 if let Some((inlined, num_bytes, num_handles)) =
8136 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8137 {
8138 let member_inline_size =
8139 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8140 if inlined != (member_inline_size <= 4) {
8141 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8142 }
8143 let inner_offset;
8144 let mut inner_depth = depth.clone();
8145 if inlined {
8146 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8147 inner_offset = next_offset;
8148 } else {
8149 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8150 inner_depth.increment()?;
8151 }
8152 let val_ref = self.enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
8153 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8154 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8155 {
8156 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8157 }
8158 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8159 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8160 }
8161 }
8162
8163 next_offset += envelope_size;
8164
8165 while next_offset < end_offset {
8167 _next_ordinal_to_read += 1;
8168 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8169 next_offset += envelope_size;
8170 }
8171
8172 Ok(())
8173 }
8174 }
8175
8176 impl EqualizerElementState {
8177 #[inline(always)]
8178 fn max_ordinal_present(&self) -> u64 {
8179 if let Some(_) = self.band_states {
8180 return 2;
8181 }
8182 if let Some(_) = self.bands_state {
8183 return 1;
8184 }
8185 0
8186 }
8187 }
8188
8189 impl fidl::encoding::ValueTypeMarker for EqualizerElementState {
8190 type Borrowed<'a> = &'a Self;
8191 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8192 value
8193 }
8194 }
8195
8196 unsafe impl fidl::encoding::TypeMarker for EqualizerElementState {
8197 type Owned = Self;
8198
8199 #[inline(always)]
8200 fn inline_align(_context: fidl::encoding::Context) -> usize {
8201 8
8202 }
8203
8204 #[inline(always)]
8205 fn inline_size(_context: fidl::encoding::Context) -> usize {
8206 16
8207 }
8208 }
8209
8210 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerElementState, D>
8211 for &EqualizerElementState
8212 {
8213 unsafe fn encode(
8214 self,
8215 encoder: &mut fidl::encoding::Encoder<'_, D>,
8216 offset: usize,
8217 mut depth: fidl::encoding::Depth,
8218 ) -> fidl::Result<()> {
8219 encoder.debug_check_bounds::<EqualizerElementState>(offset);
8220 let max_ordinal: u64 = self.max_ordinal_present();
8222 encoder.write_num(max_ordinal, offset);
8223 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8224 if max_ordinal == 0 {
8226 return Ok(());
8227 }
8228 depth.increment()?;
8229 let envelope_size = 8;
8230 let bytes_len = max_ordinal as usize * envelope_size;
8231 #[allow(unused_variables)]
8232 let offset = encoder.out_of_line_offset(bytes_len);
8233 let mut _prev_end_offset: usize = 0;
8234 if 1 > max_ordinal {
8235 return Ok(());
8236 }
8237
8238 let cur_offset: usize = (1 - 1) * envelope_size;
8241
8242 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8244
8245 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBandState, 64>, D>(
8250 self.bands_state.as_ref().map(<fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
8251 encoder, offset + cur_offset, depth
8252 )?;
8253
8254 _prev_end_offset = cur_offset + envelope_size;
8255 if 2 > max_ordinal {
8256 return Ok(());
8257 }
8258
8259 let cur_offset: usize = (2 - 1) * envelope_size;
8262
8263 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8265
8266 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBandState, 64>, D>(
8271 self.band_states.as_ref().map(<fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
8272 encoder, offset + cur_offset, depth
8273 )?;
8274
8275 _prev_end_offset = cur_offset + envelope_size;
8276
8277 Ok(())
8278 }
8279 }
8280
8281 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerElementState {
8282 #[inline(always)]
8283 fn new_empty() -> Self {
8284 Self::default()
8285 }
8286
8287 unsafe fn decode(
8288 &mut self,
8289 decoder: &mut fidl::encoding::Decoder<'_, D>,
8290 offset: usize,
8291 mut depth: fidl::encoding::Depth,
8292 ) -> fidl::Result<()> {
8293 decoder.debug_check_bounds::<Self>(offset);
8294 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8295 None => return Err(fidl::Error::NotNullable),
8296 Some(len) => len,
8297 };
8298 if len == 0 {
8300 return Ok(());
8301 };
8302 depth.increment()?;
8303 let envelope_size = 8;
8304 let bytes_len = len * envelope_size;
8305 let offset = decoder.out_of_line_offset(bytes_len)?;
8306 let mut _next_ordinal_to_read = 0;
8308 let mut next_offset = offset;
8309 let end_offset = offset + bytes_len;
8310 _next_ordinal_to_read += 1;
8311 if next_offset >= end_offset {
8312 return Ok(());
8313 }
8314
8315 while _next_ordinal_to_read < 1 {
8317 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8318 _next_ordinal_to_read += 1;
8319 next_offset += envelope_size;
8320 }
8321
8322 let next_out_of_line = decoder.next_out_of_line();
8323 let handles_before = decoder.remaining_handles();
8324 if let Some((inlined, num_bytes, num_handles)) =
8325 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8326 {
8327 let member_inline_size = <fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8328 if inlined != (member_inline_size <= 4) {
8329 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8330 }
8331 let inner_offset;
8332 let mut inner_depth = depth.clone();
8333 if inlined {
8334 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8335 inner_offset = next_offset;
8336 } else {
8337 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8338 inner_depth.increment()?;
8339 }
8340 let val_ref = self.bands_state.get_or_insert_with(
8341 || fidl::new_empty!(fidl::encoding::Vector<EqualizerBandState, 64>, D),
8342 );
8343 fidl::decode!(fidl::encoding::Vector<EqualizerBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
8344 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8345 {
8346 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8347 }
8348 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8349 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8350 }
8351 }
8352
8353 next_offset += envelope_size;
8354 _next_ordinal_to_read += 1;
8355 if next_offset >= end_offset {
8356 return Ok(());
8357 }
8358
8359 while _next_ordinal_to_read < 2 {
8361 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8362 _next_ordinal_to_read += 1;
8363 next_offset += envelope_size;
8364 }
8365
8366 let next_out_of_line = decoder.next_out_of_line();
8367 let handles_before = decoder.remaining_handles();
8368 if let Some((inlined, num_bytes, num_handles)) =
8369 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8370 {
8371 let member_inline_size = <fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8372 if inlined != (member_inline_size <= 4) {
8373 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8374 }
8375 let inner_offset;
8376 let mut inner_depth = depth.clone();
8377 if inlined {
8378 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8379 inner_offset = next_offset;
8380 } else {
8381 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8382 inner_depth.increment()?;
8383 }
8384 let val_ref = self.band_states.get_or_insert_with(
8385 || fidl::new_empty!(fidl::encoding::Vector<EqualizerBandState, 64>, D),
8386 );
8387 fidl::decode!(fidl::encoding::Vector<EqualizerBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
8388 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8389 {
8390 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8391 }
8392 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8393 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8394 }
8395 }
8396
8397 next_offset += envelope_size;
8398
8399 while next_offset < end_offset {
8401 _next_ordinal_to_read += 1;
8402 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8403 next_offset += envelope_size;
8404 }
8405
8406 Ok(())
8407 }
8408 }
8409
8410 impl Gain {
8411 #[inline(always)]
8412 fn max_ordinal_present(&self) -> u64 {
8413 if let Some(_) = self.min_gain_step {
8414 return 5;
8415 }
8416 if let Some(_) = self.max_gain {
8417 return 4;
8418 }
8419 if let Some(_) = self.min_gain {
8420 return 3;
8421 }
8422 if let Some(_) = self.domain {
8423 return 2;
8424 }
8425 if let Some(_) = self.type_ {
8426 return 1;
8427 }
8428 0
8429 }
8430 }
8431
8432 impl fidl::encoding::ValueTypeMarker for Gain {
8433 type Borrowed<'a> = &'a Self;
8434 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8435 value
8436 }
8437 }
8438
8439 unsafe impl fidl::encoding::TypeMarker for Gain {
8440 type Owned = Self;
8441
8442 #[inline(always)]
8443 fn inline_align(_context: fidl::encoding::Context) -> usize {
8444 8
8445 }
8446
8447 #[inline(always)]
8448 fn inline_size(_context: fidl::encoding::Context) -> usize {
8449 16
8450 }
8451 }
8452
8453 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Gain, D> for &Gain {
8454 unsafe fn encode(
8455 self,
8456 encoder: &mut fidl::encoding::Encoder<'_, D>,
8457 offset: usize,
8458 mut depth: fidl::encoding::Depth,
8459 ) -> fidl::Result<()> {
8460 encoder.debug_check_bounds::<Gain>(offset);
8461 let max_ordinal: u64 = self.max_ordinal_present();
8463 encoder.write_num(max_ordinal, offset);
8464 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8465 if max_ordinal == 0 {
8467 return Ok(());
8468 }
8469 depth.increment()?;
8470 let envelope_size = 8;
8471 let bytes_len = max_ordinal as usize * envelope_size;
8472 #[allow(unused_variables)]
8473 let offset = encoder.out_of_line_offset(bytes_len);
8474 let mut _prev_end_offset: usize = 0;
8475 if 1 > max_ordinal {
8476 return Ok(());
8477 }
8478
8479 let cur_offset: usize = (1 - 1) * envelope_size;
8482
8483 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8485
8486 fidl::encoding::encode_in_envelope_optional::<GainType, D>(
8491 self.type_.as_ref().map(<GainType as fidl::encoding::ValueTypeMarker>::borrow),
8492 encoder,
8493 offset + cur_offset,
8494 depth,
8495 )?;
8496
8497 _prev_end_offset = cur_offset + envelope_size;
8498 if 2 > max_ordinal {
8499 return Ok(());
8500 }
8501
8502 let cur_offset: usize = (2 - 1) * envelope_size;
8505
8506 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8508
8509 fidl::encoding::encode_in_envelope_optional::<GainDomain, D>(
8514 self.domain.as_ref().map(<GainDomain as fidl::encoding::ValueTypeMarker>::borrow),
8515 encoder,
8516 offset + cur_offset,
8517 depth,
8518 )?;
8519
8520 _prev_end_offset = cur_offset + envelope_size;
8521 if 3 > max_ordinal {
8522 return Ok(());
8523 }
8524
8525 let cur_offset: usize = (3 - 1) * envelope_size;
8528
8529 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8531
8532 fidl::encoding::encode_in_envelope_optional::<f32, D>(
8537 self.min_gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8538 encoder,
8539 offset + cur_offset,
8540 depth,
8541 )?;
8542
8543 _prev_end_offset = cur_offset + envelope_size;
8544 if 4 > max_ordinal {
8545 return Ok(());
8546 }
8547
8548 let cur_offset: usize = (4 - 1) * envelope_size;
8551
8552 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8554
8555 fidl::encoding::encode_in_envelope_optional::<f32, D>(
8560 self.max_gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8561 encoder,
8562 offset + cur_offset,
8563 depth,
8564 )?;
8565
8566 _prev_end_offset = cur_offset + envelope_size;
8567 if 5 > max_ordinal {
8568 return Ok(());
8569 }
8570
8571 let cur_offset: usize = (5 - 1) * envelope_size;
8574
8575 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8577
8578 fidl::encoding::encode_in_envelope_optional::<f32, D>(
8583 self.min_gain_step.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8584 encoder,
8585 offset + cur_offset,
8586 depth,
8587 )?;
8588
8589 _prev_end_offset = cur_offset + envelope_size;
8590
8591 Ok(())
8592 }
8593 }
8594
8595 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Gain {
8596 #[inline(always)]
8597 fn new_empty() -> Self {
8598 Self::default()
8599 }
8600
8601 unsafe fn decode(
8602 &mut self,
8603 decoder: &mut fidl::encoding::Decoder<'_, D>,
8604 offset: usize,
8605 mut depth: fidl::encoding::Depth,
8606 ) -> fidl::Result<()> {
8607 decoder.debug_check_bounds::<Self>(offset);
8608 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8609 None => return Err(fidl::Error::NotNullable),
8610 Some(len) => len,
8611 };
8612 if len == 0 {
8614 return Ok(());
8615 };
8616 depth.increment()?;
8617 let envelope_size = 8;
8618 let bytes_len = len * envelope_size;
8619 let offset = decoder.out_of_line_offset(bytes_len)?;
8620 let mut _next_ordinal_to_read = 0;
8622 let mut next_offset = offset;
8623 let end_offset = offset + bytes_len;
8624 _next_ordinal_to_read += 1;
8625 if next_offset >= end_offset {
8626 return Ok(());
8627 }
8628
8629 while _next_ordinal_to_read < 1 {
8631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8632 _next_ordinal_to_read += 1;
8633 next_offset += envelope_size;
8634 }
8635
8636 let next_out_of_line = decoder.next_out_of_line();
8637 let handles_before = decoder.remaining_handles();
8638 if let Some((inlined, num_bytes, num_handles)) =
8639 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8640 {
8641 let member_inline_size =
8642 <GainType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8643 if inlined != (member_inline_size <= 4) {
8644 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8645 }
8646 let inner_offset;
8647 let mut inner_depth = depth.clone();
8648 if inlined {
8649 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8650 inner_offset = next_offset;
8651 } else {
8652 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8653 inner_depth.increment()?;
8654 }
8655 let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(GainType, D));
8656 fidl::decode!(GainType, D, val_ref, decoder, inner_offset, inner_depth)?;
8657 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8658 {
8659 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8660 }
8661 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8662 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8663 }
8664 }
8665
8666 next_offset += envelope_size;
8667 _next_ordinal_to_read += 1;
8668 if next_offset >= end_offset {
8669 return Ok(());
8670 }
8671
8672 while _next_ordinal_to_read < 2 {
8674 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8675 _next_ordinal_to_read += 1;
8676 next_offset += envelope_size;
8677 }
8678
8679 let next_out_of_line = decoder.next_out_of_line();
8680 let handles_before = decoder.remaining_handles();
8681 if let Some((inlined, num_bytes, num_handles)) =
8682 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8683 {
8684 let member_inline_size =
8685 <GainDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8686 if inlined != (member_inline_size <= 4) {
8687 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8688 }
8689 let inner_offset;
8690 let mut inner_depth = depth.clone();
8691 if inlined {
8692 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8693 inner_offset = next_offset;
8694 } else {
8695 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8696 inner_depth.increment()?;
8697 }
8698 let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(GainDomain, D));
8699 fidl::decode!(GainDomain, D, val_ref, decoder, inner_offset, inner_depth)?;
8700 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8701 {
8702 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8703 }
8704 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8705 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8706 }
8707 }
8708
8709 next_offset += envelope_size;
8710 _next_ordinal_to_read += 1;
8711 if next_offset >= end_offset {
8712 return Ok(());
8713 }
8714
8715 while _next_ordinal_to_read < 3 {
8717 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8718 _next_ordinal_to_read += 1;
8719 next_offset += envelope_size;
8720 }
8721
8722 let next_out_of_line = decoder.next_out_of_line();
8723 let handles_before = decoder.remaining_handles();
8724 if let Some((inlined, num_bytes, num_handles)) =
8725 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8726 {
8727 let member_inline_size =
8728 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8729 if inlined != (member_inline_size <= 4) {
8730 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8731 }
8732 let inner_offset;
8733 let mut inner_depth = depth.clone();
8734 if inlined {
8735 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8736 inner_offset = next_offset;
8737 } else {
8738 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8739 inner_depth.increment()?;
8740 }
8741 let val_ref = self.min_gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8742 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8743 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8744 {
8745 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8746 }
8747 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8748 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8749 }
8750 }
8751
8752 next_offset += envelope_size;
8753 _next_ordinal_to_read += 1;
8754 if next_offset >= end_offset {
8755 return Ok(());
8756 }
8757
8758 while _next_ordinal_to_read < 4 {
8760 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8761 _next_ordinal_to_read += 1;
8762 next_offset += envelope_size;
8763 }
8764
8765 let next_out_of_line = decoder.next_out_of_line();
8766 let handles_before = decoder.remaining_handles();
8767 if let Some((inlined, num_bytes, num_handles)) =
8768 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8769 {
8770 let member_inline_size =
8771 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8772 if inlined != (member_inline_size <= 4) {
8773 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8774 }
8775 let inner_offset;
8776 let mut inner_depth = depth.clone();
8777 if inlined {
8778 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8779 inner_offset = next_offset;
8780 } else {
8781 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8782 inner_depth.increment()?;
8783 }
8784 let val_ref = self.max_gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8785 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8786 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8787 {
8788 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8789 }
8790 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8791 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8792 }
8793 }
8794
8795 next_offset += envelope_size;
8796 _next_ordinal_to_read += 1;
8797 if next_offset >= end_offset {
8798 return Ok(());
8799 }
8800
8801 while _next_ordinal_to_read < 5 {
8803 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8804 _next_ordinal_to_read += 1;
8805 next_offset += envelope_size;
8806 }
8807
8808 let next_out_of_line = decoder.next_out_of_line();
8809 let handles_before = decoder.remaining_handles();
8810 if let Some((inlined, num_bytes, num_handles)) =
8811 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8812 {
8813 let member_inline_size =
8814 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8815 if inlined != (member_inline_size <= 4) {
8816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8817 }
8818 let inner_offset;
8819 let mut inner_depth = depth.clone();
8820 if inlined {
8821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8822 inner_offset = next_offset;
8823 } else {
8824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8825 inner_depth.increment()?;
8826 }
8827 let val_ref = self.min_gain_step.get_or_insert_with(|| fidl::new_empty!(f32, D));
8828 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8829 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8830 {
8831 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8832 }
8833 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8834 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8835 }
8836 }
8837
8838 next_offset += envelope_size;
8839
8840 while next_offset < end_offset {
8842 _next_ordinal_to_read += 1;
8843 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8844 next_offset += envelope_size;
8845 }
8846
8847 Ok(())
8848 }
8849 }
8850
8851 impl GainElementState {
8852 #[inline(always)]
8853 fn max_ordinal_present(&self) -> u64 {
8854 if let Some(_) = self.gain {
8855 return 1;
8856 }
8857 0
8858 }
8859 }
8860
8861 impl fidl::encoding::ValueTypeMarker for GainElementState {
8862 type Borrowed<'a> = &'a Self;
8863 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8864 value
8865 }
8866 }
8867
8868 unsafe impl fidl::encoding::TypeMarker for GainElementState {
8869 type Owned = Self;
8870
8871 #[inline(always)]
8872 fn inline_align(_context: fidl::encoding::Context) -> usize {
8873 8
8874 }
8875
8876 #[inline(always)]
8877 fn inline_size(_context: fidl::encoding::Context) -> usize {
8878 16
8879 }
8880 }
8881
8882 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GainElementState, D>
8883 for &GainElementState
8884 {
8885 unsafe fn encode(
8886 self,
8887 encoder: &mut fidl::encoding::Encoder<'_, D>,
8888 offset: usize,
8889 mut depth: fidl::encoding::Depth,
8890 ) -> fidl::Result<()> {
8891 encoder.debug_check_bounds::<GainElementState>(offset);
8892 let max_ordinal: u64 = self.max_ordinal_present();
8894 encoder.write_num(max_ordinal, offset);
8895 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8896 if max_ordinal == 0 {
8898 return Ok(());
8899 }
8900 depth.increment()?;
8901 let envelope_size = 8;
8902 let bytes_len = max_ordinal as usize * envelope_size;
8903 #[allow(unused_variables)]
8904 let offset = encoder.out_of_line_offset(bytes_len);
8905 let mut _prev_end_offset: usize = 0;
8906 if 1 > max_ordinal {
8907 return Ok(());
8908 }
8909
8910 let cur_offset: usize = (1 - 1) * envelope_size;
8913
8914 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8916
8917 fidl::encoding::encode_in_envelope_optional::<f32, D>(
8922 self.gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8923 encoder,
8924 offset + cur_offset,
8925 depth,
8926 )?;
8927
8928 _prev_end_offset = cur_offset + envelope_size;
8929
8930 Ok(())
8931 }
8932 }
8933
8934 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainElementState {
8935 #[inline(always)]
8936 fn new_empty() -> Self {
8937 Self::default()
8938 }
8939
8940 unsafe fn decode(
8941 &mut self,
8942 decoder: &mut fidl::encoding::Decoder<'_, D>,
8943 offset: usize,
8944 mut depth: fidl::encoding::Depth,
8945 ) -> fidl::Result<()> {
8946 decoder.debug_check_bounds::<Self>(offset);
8947 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8948 None => return Err(fidl::Error::NotNullable),
8949 Some(len) => len,
8950 };
8951 if len == 0 {
8953 return Ok(());
8954 };
8955 depth.increment()?;
8956 let envelope_size = 8;
8957 let bytes_len = len * envelope_size;
8958 let offset = decoder.out_of_line_offset(bytes_len)?;
8959 let mut _next_ordinal_to_read = 0;
8961 let mut next_offset = offset;
8962 let end_offset = offset + bytes_len;
8963 _next_ordinal_to_read += 1;
8964 if next_offset >= end_offset {
8965 return Ok(());
8966 }
8967
8968 while _next_ordinal_to_read < 1 {
8970 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8971 _next_ordinal_to_read += 1;
8972 next_offset += envelope_size;
8973 }
8974
8975 let next_out_of_line = decoder.next_out_of_line();
8976 let handles_before = decoder.remaining_handles();
8977 if let Some((inlined, num_bytes, num_handles)) =
8978 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8979 {
8980 let member_inline_size =
8981 <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8982 if inlined != (member_inline_size <= 4) {
8983 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8984 }
8985 let inner_offset;
8986 let mut inner_depth = depth.clone();
8987 if inlined {
8988 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8989 inner_offset = next_offset;
8990 } else {
8991 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8992 inner_depth.increment()?;
8993 }
8994 let val_ref = self.gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8995 fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8996 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8997 {
8998 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8999 }
9000 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9001 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9002 }
9003 }
9004
9005 next_offset += envelope_size;
9006
9007 while next_offset < end_offset {
9009 _next_ordinal_to_read += 1;
9010 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9011 next_offset += envelope_size;
9012 }
9013
9014 Ok(())
9015 }
9016 }
9017
9018 impl PlugState {
9019 #[inline(always)]
9020 fn max_ordinal_present(&self) -> u64 {
9021 if let Some(_) = self.plug_state_time {
9022 return 2;
9023 }
9024 if let Some(_) = self.plugged {
9025 return 1;
9026 }
9027 0
9028 }
9029 }
9030
9031 impl fidl::encoding::ValueTypeMarker for PlugState {
9032 type Borrowed<'a> = &'a Self;
9033 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9034 value
9035 }
9036 }
9037
9038 unsafe impl fidl::encoding::TypeMarker for PlugState {
9039 type Owned = Self;
9040
9041 #[inline(always)]
9042 fn inline_align(_context: fidl::encoding::Context) -> usize {
9043 8
9044 }
9045
9046 #[inline(always)]
9047 fn inline_size(_context: fidl::encoding::Context) -> usize {
9048 16
9049 }
9050 }
9051
9052 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PlugState, D>
9053 for &PlugState
9054 {
9055 unsafe fn encode(
9056 self,
9057 encoder: &mut fidl::encoding::Encoder<'_, D>,
9058 offset: usize,
9059 mut depth: fidl::encoding::Depth,
9060 ) -> fidl::Result<()> {
9061 encoder.debug_check_bounds::<PlugState>(offset);
9062 let max_ordinal: u64 = self.max_ordinal_present();
9064 encoder.write_num(max_ordinal, offset);
9065 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9066 if max_ordinal == 0 {
9068 return Ok(());
9069 }
9070 depth.increment()?;
9071 let envelope_size = 8;
9072 let bytes_len = max_ordinal as usize * envelope_size;
9073 #[allow(unused_variables)]
9074 let offset = encoder.out_of_line_offset(bytes_len);
9075 let mut _prev_end_offset: usize = 0;
9076 if 1 > max_ordinal {
9077 return Ok(());
9078 }
9079
9080 let cur_offset: usize = (1 - 1) * envelope_size;
9083
9084 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9086
9087 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9092 self.plugged.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9093 encoder,
9094 offset + cur_offset,
9095 depth,
9096 )?;
9097
9098 _prev_end_offset = cur_offset + envelope_size;
9099 if 2 > max_ordinal {
9100 return Ok(());
9101 }
9102
9103 let cur_offset: usize = (2 - 1) * envelope_size;
9106
9107 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9109
9110 fidl::encoding::encode_in_envelope_optional::<i64, D>(
9115 self.plug_state_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9116 encoder,
9117 offset + cur_offset,
9118 depth,
9119 )?;
9120
9121 _prev_end_offset = cur_offset + envelope_size;
9122
9123 Ok(())
9124 }
9125 }
9126
9127 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
9128 #[inline(always)]
9129 fn new_empty() -> Self {
9130 Self::default()
9131 }
9132
9133 unsafe fn decode(
9134 &mut self,
9135 decoder: &mut fidl::encoding::Decoder<'_, D>,
9136 offset: usize,
9137 mut depth: fidl::encoding::Depth,
9138 ) -> fidl::Result<()> {
9139 decoder.debug_check_bounds::<Self>(offset);
9140 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9141 None => return Err(fidl::Error::NotNullable),
9142 Some(len) => len,
9143 };
9144 if len == 0 {
9146 return Ok(());
9147 };
9148 depth.increment()?;
9149 let envelope_size = 8;
9150 let bytes_len = len * envelope_size;
9151 let offset = decoder.out_of_line_offset(bytes_len)?;
9152 let mut _next_ordinal_to_read = 0;
9154 let mut next_offset = offset;
9155 let end_offset = offset + bytes_len;
9156 _next_ordinal_to_read += 1;
9157 if next_offset >= end_offset {
9158 return Ok(());
9159 }
9160
9161 while _next_ordinal_to_read < 1 {
9163 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9164 _next_ordinal_to_read += 1;
9165 next_offset += envelope_size;
9166 }
9167
9168 let next_out_of_line = decoder.next_out_of_line();
9169 let handles_before = decoder.remaining_handles();
9170 if let Some((inlined, num_bytes, num_handles)) =
9171 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9172 {
9173 let member_inline_size =
9174 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9175 if inlined != (member_inline_size <= 4) {
9176 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9177 }
9178 let inner_offset;
9179 let mut inner_depth = depth.clone();
9180 if inlined {
9181 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9182 inner_offset = next_offset;
9183 } else {
9184 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9185 inner_depth.increment()?;
9186 }
9187 let val_ref = self.plugged.get_or_insert_with(|| fidl::new_empty!(bool, D));
9188 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9189 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9190 {
9191 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9192 }
9193 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9194 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9195 }
9196 }
9197
9198 next_offset += envelope_size;
9199 _next_ordinal_to_read += 1;
9200 if next_offset >= end_offset {
9201 return Ok(());
9202 }
9203
9204 while _next_ordinal_to_read < 2 {
9206 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9207 _next_ordinal_to_read += 1;
9208 next_offset += envelope_size;
9209 }
9210
9211 let next_out_of_line = decoder.next_out_of_line();
9212 let handles_before = decoder.remaining_handles();
9213 if let Some((inlined, num_bytes, num_handles)) =
9214 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9215 {
9216 let member_inline_size =
9217 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9218 if inlined != (member_inline_size <= 4) {
9219 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9220 }
9221 let inner_offset;
9222 let mut inner_depth = depth.clone();
9223 if inlined {
9224 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9225 inner_offset = next_offset;
9226 } else {
9227 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9228 inner_depth.increment()?;
9229 }
9230 let val_ref = self.plug_state_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
9231 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9232 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9233 {
9234 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9235 }
9236 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9237 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9238 }
9239 }
9240
9241 next_offset += envelope_size;
9242
9243 while next_offset < end_offset {
9245 _next_ordinal_to_read += 1;
9246 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9247 next_offset += envelope_size;
9248 }
9249
9250 Ok(())
9251 }
9252 }
9253
9254 impl SettableElementState {
9255 #[inline(always)]
9256 fn max_ordinal_present(&self) -> u64 {
9257 if let Some(_) = self.bypassed {
9258 return 4;
9259 }
9260 if let Some(_) = self.started {
9261 return 3;
9262 }
9263 if let Some(_) = self.vendor_specific_data {
9264 return 2;
9265 }
9266 if let Some(_) = self.type_specific {
9267 return 1;
9268 }
9269 0
9270 }
9271 }
9272
9273 impl fidl::encoding::ValueTypeMarker for SettableElementState {
9274 type Borrowed<'a> = &'a Self;
9275 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9276 value
9277 }
9278 }
9279
9280 unsafe impl fidl::encoding::TypeMarker for SettableElementState {
9281 type Owned = Self;
9282
9283 #[inline(always)]
9284 fn inline_align(_context: fidl::encoding::Context) -> usize {
9285 8
9286 }
9287
9288 #[inline(always)]
9289 fn inline_size(_context: fidl::encoding::Context) -> usize {
9290 16
9291 }
9292 }
9293
9294 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SettableElementState, D>
9295 for &SettableElementState
9296 {
9297 unsafe fn encode(
9298 self,
9299 encoder: &mut fidl::encoding::Encoder<'_, D>,
9300 offset: usize,
9301 mut depth: fidl::encoding::Depth,
9302 ) -> fidl::Result<()> {
9303 encoder.debug_check_bounds::<SettableElementState>(offset);
9304 let max_ordinal: u64 = self.max_ordinal_present();
9306 encoder.write_num(max_ordinal, offset);
9307 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9308 if max_ordinal == 0 {
9310 return Ok(());
9311 }
9312 depth.increment()?;
9313 let envelope_size = 8;
9314 let bytes_len = max_ordinal as usize * envelope_size;
9315 #[allow(unused_variables)]
9316 let offset = encoder.out_of_line_offset(bytes_len);
9317 let mut _prev_end_offset: usize = 0;
9318 if 1 > max_ordinal {
9319 return Ok(());
9320 }
9321
9322 let cur_offset: usize = (1 - 1) * envelope_size;
9325
9326 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9328
9329 fidl::encoding::encode_in_envelope_optional::<SettableTypeSpecificElementState, D>(
9334 self.type_specific.as_ref().map(
9335 <SettableTypeSpecificElementState as fidl::encoding::ValueTypeMarker>::borrow,
9336 ),
9337 encoder,
9338 offset + cur_offset,
9339 depth,
9340 )?;
9341
9342 _prev_end_offset = cur_offset + envelope_size;
9343 if 2 > max_ordinal {
9344 return Ok(());
9345 }
9346
9347 let cur_offset: usize = (2 - 1) * envelope_size;
9350
9351 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9353
9354 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4096>, D>(
9359 self.vendor_specific_data.as_ref().map(
9360 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow,
9361 ),
9362 encoder,
9363 offset + cur_offset,
9364 depth,
9365 )?;
9366
9367 _prev_end_offset = cur_offset + envelope_size;
9368 if 3 > max_ordinal {
9369 return Ok(());
9370 }
9371
9372 let cur_offset: usize = (3 - 1) * envelope_size;
9375
9376 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9378
9379 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9384 self.started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9385 encoder,
9386 offset + cur_offset,
9387 depth,
9388 )?;
9389
9390 _prev_end_offset = cur_offset + envelope_size;
9391 if 4 > max_ordinal {
9392 return Ok(());
9393 }
9394
9395 let cur_offset: usize = (4 - 1) * envelope_size;
9398
9399 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9401
9402 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9407 self.bypassed.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9408 encoder,
9409 offset + cur_offset,
9410 depth,
9411 )?;
9412
9413 _prev_end_offset = cur_offset + envelope_size;
9414
9415 Ok(())
9416 }
9417 }
9418
9419 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SettableElementState {
9420 #[inline(always)]
9421 fn new_empty() -> Self {
9422 Self::default()
9423 }
9424
9425 unsafe fn decode(
9426 &mut self,
9427 decoder: &mut fidl::encoding::Decoder<'_, D>,
9428 offset: usize,
9429 mut depth: fidl::encoding::Depth,
9430 ) -> fidl::Result<()> {
9431 decoder.debug_check_bounds::<Self>(offset);
9432 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9433 None => return Err(fidl::Error::NotNullable),
9434 Some(len) => len,
9435 };
9436 if len == 0 {
9438 return Ok(());
9439 };
9440 depth.increment()?;
9441 let envelope_size = 8;
9442 let bytes_len = len * envelope_size;
9443 let offset = decoder.out_of_line_offset(bytes_len)?;
9444 let mut _next_ordinal_to_read = 0;
9446 let mut next_offset = offset;
9447 let end_offset = offset + bytes_len;
9448 _next_ordinal_to_read += 1;
9449 if next_offset >= end_offset {
9450 return Ok(());
9451 }
9452
9453 while _next_ordinal_to_read < 1 {
9455 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9456 _next_ordinal_to_read += 1;
9457 next_offset += envelope_size;
9458 }
9459
9460 let next_out_of_line = decoder.next_out_of_line();
9461 let handles_before = decoder.remaining_handles();
9462 if let Some((inlined, num_bytes, num_handles)) =
9463 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9464 {
9465 let member_inline_size =
9466 <SettableTypeSpecificElementState as fidl::encoding::TypeMarker>::inline_size(
9467 decoder.context,
9468 );
9469 if inlined != (member_inline_size <= 4) {
9470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9471 }
9472 let inner_offset;
9473 let mut inner_depth = depth.clone();
9474 if inlined {
9475 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9476 inner_offset = next_offset;
9477 } else {
9478 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9479 inner_depth.increment()?;
9480 }
9481 let val_ref = self
9482 .type_specific
9483 .get_or_insert_with(|| fidl::new_empty!(SettableTypeSpecificElementState, D));
9484 fidl::decode!(
9485 SettableTypeSpecificElementState,
9486 D,
9487 val_ref,
9488 decoder,
9489 inner_offset,
9490 inner_depth
9491 )?;
9492 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9493 {
9494 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9495 }
9496 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9497 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9498 }
9499 }
9500
9501 next_offset += envelope_size;
9502 _next_ordinal_to_read += 1;
9503 if next_offset >= end_offset {
9504 return Ok(());
9505 }
9506
9507 while _next_ordinal_to_read < 2 {
9509 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9510 _next_ordinal_to_read += 1;
9511 next_offset += envelope_size;
9512 }
9513
9514 let next_out_of_line = decoder.next_out_of_line();
9515 let handles_before = decoder.remaining_handles();
9516 if let Some((inlined, num_bytes, num_handles)) =
9517 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9518 {
9519 let member_inline_size =
9520 <fidl::encoding::Vector<u8, 4096> as fidl::encoding::TypeMarker>::inline_size(
9521 decoder.context,
9522 );
9523 if inlined != (member_inline_size <= 4) {
9524 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9525 }
9526 let inner_offset;
9527 let mut inner_depth = depth.clone();
9528 if inlined {
9529 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9530 inner_offset = next_offset;
9531 } else {
9532 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9533 inner_depth.increment()?;
9534 }
9535 let val_ref = self
9536 .vendor_specific_data
9537 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D));
9538 fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
9539 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9540 {
9541 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9542 }
9543 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9544 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9545 }
9546 }
9547
9548 next_offset += envelope_size;
9549 _next_ordinal_to_read += 1;
9550 if next_offset >= end_offset {
9551 return Ok(());
9552 }
9553
9554 while _next_ordinal_to_read < 3 {
9556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9557 _next_ordinal_to_read += 1;
9558 next_offset += envelope_size;
9559 }
9560
9561 let next_out_of_line = decoder.next_out_of_line();
9562 let handles_before = decoder.remaining_handles();
9563 if let Some((inlined, num_bytes, num_handles)) =
9564 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9565 {
9566 let member_inline_size =
9567 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9568 if inlined != (member_inline_size <= 4) {
9569 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9570 }
9571 let inner_offset;
9572 let mut inner_depth = depth.clone();
9573 if inlined {
9574 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9575 inner_offset = next_offset;
9576 } else {
9577 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9578 inner_depth.increment()?;
9579 }
9580 let val_ref = self.started.get_or_insert_with(|| fidl::new_empty!(bool, D));
9581 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9582 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9583 {
9584 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9585 }
9586 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9587 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9588 }
9589 }
9590
9591 next_offset += envelope_size;
9592 _next_ordinal_to_read += 1;
9593 if next_offset >= end_offset {
9594 return Ok(());
9595 }
9596
9597 while _next_ordinal_to_read < 4 {
9599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9600 _next_ordinal_to_read += 1;
9601 next_offset += envelope_size;
9602 }
9603
9604 let next_out_of_line = decoder.next_out_of_line();
9605 let handles_before = decoder.remaining_handles();
9606 if let Some((inlined, num_bytes, num_handles)) =
9607 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9608 {
9609 let member_inline_size =
9610 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9611 if inlined != (member_inline_size <= 4) {
9612 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9613 }
9614 let inner_offset;
9615 let mut inner_depth = depth.clone();
9616 if inlined {
9617 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9618 inner_offset = next_offset;
9619 } else {
9620 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9621 inner_depth.increment()?;
9622 }
9623 let val_ref = self.bypassed.get_or_insert_with(|| fidl::new_empty!(bool, D));
9624 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9625 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9626 {
9627 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9628 }
9629 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9630 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9631 }
9632 }
9633
9634 next_offset += envelope_size;
9635
9636 while next_offset < end_offset {
9638 _next_ordinal_to_read += 1;
9639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9640 next_offset += envelope_size;
9641 }
9642
9643 Ok(())
9644 }
9645 }
9646
9647 impl Topology {
9648 #[inline(always)]
9649 fn max_ordinal_present(&self) -> u64 {
9650 if let Some(_) = self.processing_elements_edge_pairs {
9651 return 2;
9652 }
9653 if let Some(_) = self.id {
9654 return 1;
9655 }
9656 0
9657 }
9658 }
9659
9660 impl fidl::encoding::ValueTypeMarker for Topology {
9661 type Borrowed<'a> = &'a Self;
9662 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9663 value
9664 }
9665 }
9666
9667 unsafe impl fidl::encoding::TypeMarker for Topology {
9668 type Owned = Self;
9669
9670 #[inline(always)]
9671 fn inline_align(_context: fidl::encoding::Context) -> usize {
9672 8
9673 }
9674
9675 #[inline(always)]
9676 fn inline_size(_context: fidl::encoding::Context) -> usize {
9677 16
9678 }
9679 }
9680
9681 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Topology, D> for &Topology {
9682 unsafe fn encode(
9683 self,
9684 encoder: &mut fidl::encoding::Encoder<'_, D>,
9685 offset: usize,
9686 mut depth: fidl::encoding::Depth,
9687 ) -> fidl::Result<()> {
9688 encoder.debug_check_bounds::<Topology>(offset);
9689 let max_ordinal: u64 = self.max_ordinal_present();
9691 encoder.write_num(max_ordinal, offset);
9692 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9693 if max_ordinal == 0 {
9695 return Ok(());
9696 }
9697 depth.increment()?;
9698 let envelope_size = 8;
9699 let bytes_len = max_ordinal as usize * envelope_size;
9700 #[allow(unused_variables)]
9701 let offset = encoder.out_of_line_offset(bytes_len);
9702 let mut _prev_end_offset: usize = 0;
9703 if 1 > max_ordinal {
9704 return Ok(());
9705 }
9706
9707 let cur_offset: usize = (1 - 1) * envelope_size;
9710
9711 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9713
9714 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9719 self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9720 encoder,
9721 offset + cur_offset,
9722 depth,
9723 )?;
9724
9725 _prev_end_offset = cur_offset + envelope_size;
9726 if 2 > max_ordinal {
9727 return Ok(());
9728 }
9729
9730 let cur_offset: usize = (2 - 1) * envelope_size;
9733
9734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9736
9737 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EdgePair, 64>, D>(
9742 self.processing_elements_edge_pairs.as_ref().map(<fidl::encoding::Vector<EdgePair, 64> as fidl::encoding::ValueTypeMarker>::borrow),
9743 encoder, offset + cur_offset, depth
9744 )?;
9745
9746 _prev_end_offset = cur_offset + envelope_size;
9747
9748 Ok(())
9749 }
9750 }
9751
9752 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Topology {
9753 #[inline(always)]
9754 fn new_empty() -> Self {
9755 Self::default()
9756 }
9757
9758 unsafe fn decode(
9759 &mut self,
9760 decoder: &mut fidl::encoding::Decoder<'_, D>,
9761 offset: usize,
9762 mut depth: fidl::encoding::Depth,
9763 ) -> fidl::Result<()> {
9764 decoder.debug_check_bounds::<Self>(offset);
9765 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9766 None => return Err(fidl::Error::NotNullable),
9767 Some(len) => len,
9768 };
9769 if len == 0 {
9771 return Ok(());
9772 };
9773 depth.increment()?;
9774 let envelope_size = 8;
9775 let bytes_len = len * envelope_size;
9776 let offset = decoder.out_of_line_offset(bytes_len)?;
9777 let mut _next_ordinal_to_read = 0;
9779 let mut next_offset = offset;
9780 let end_offset = offset + bytes_len;
9781 _next_ordinal_to_read += 1;
9782 if next_offset >= end_offset {
9783 return Ok(());
9784 }
9785
9786 while _next_ordinal_to_read < 1 {
9788 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9789 _next_ordinal_to_read += 1;
9790 next_offset += envelope_size;
9791 }
9792
9793 let next_out_of_line = decoder.next_out_of_line();
9794 let handles_before = decoder.remaining_handles();
9795 if let Some((inlined, num_bytes, num_handles)) =
9796 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9797 {
9798 let member_inline_size =
9799 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9800 if inlined != (member_inline_size <= 4) {
9801 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9802 }
9803 let inner_offset;
9804 let mut inner_depth = depth.clone();
9805 if inlined {
9806 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9807 inner_offset = next_offset;
9808 } else {
9809 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9810 inner_depth.increment()?;
9811 }
9812 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9813 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9814 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9815 {
9816 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9817 }
9818 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9819 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9820 }
9821 }
9822
9823 next_offset += envelope_size;
9824 _next_ordinal_to_read += 1;
9825 if next_offset >= end_offset {
9826 return Ok(());
9827 }
9828
9829 while _next_ordinal_to_read < 2 {
9831 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9832 _next_ordinal_to_read += 1;
9833 next_offset += envelope_size;
9834 }
9835
9836 let next_out_of_line = decoder.next_out_of_line();
9837 let handles_before = decoder.remaining_handles();
9838 if let Some((inlined, num_bytes, num_handles)) =
9839 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9840 {
9841 let member_inline_size = <fidl::encoding::Vector<EdgePair, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9842 if inlined != (member_inline_size <= 4) {
9843 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9844 }
9845 let inner_offset;
9846 let mut inner_depth = depth.clone();
9847 if inlined {
9848 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9849 inner_offset = next_offset;
9850 } else {
9851 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9852 inner_depth.increment()?;
9853 }
9854 let val_ref = self.processing_elements_edge_pairs.get_or_insert_with(
9855 || fidl::new_empty!(fidl::encoding::Vector<EdgePair, 64>, D),
9856 );
9857 fidl::decode!(fidl::encoding::Vector<EdgePair, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
9858 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9859 {
9860 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9861 }
9862 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9863 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9864 }
9865 }
9866
9867 next_offset += envelope_size;
9868
9869 while next_offset < end_offset {
9871 _next_ordinal_to_read += 1;
9872 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9873 next_offset += envelope_size;
9874 }
9875
9876 Ok(())
9877 }
9878 }
9879
9880 impl VendorSpecific {
9881 #[inline(always)]
9882 fn max_ordinal_present(&self) -> u64 {
9883 0
9884 }
9885 }
9886
9887 impl fidl::encoding::ValueTypeMarker for VendorSpecific {
9888 type Borrowed<'a> = &'a Self;
9889 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9890 value
9891 }
9892 }
9893
9894 unsafe impl fidl::encoding::TypeMarker for VendorSpecific {
9895 type Owned = Self;
9896
9897 #[inline(always)]
9898 fn inline_align(_context: fidl::encoding::Context) -> usize {
9899 8
9900 }
9901
9902 #[inline(always)]
9903 fn inline_size(_context: fidl::encoding::Context) -> usize {
9904 16
9905 }
9906 }
9907
9908 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VendorSpecific, D>
9909 for &VendorSpecific
9910 {
9911 unsafe fn encode(
9912 self,
9913 encoder: &mut fidl::encoding::Encoder<'_, D>,
9914 offset: usize,
9915 mut depth: fidl::encoding::Depth,
9916 ) -> fidl::Result<()> {
9917 encoder.debug_check_bounds::<VendorSpecific>(offset);
9918 let max_ordinal: u64 = self.max_ordinal_present();
9920 encoder.write_num(max_ordinal, offset);
9921 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9922 if max_ordinal == 0 {
9924 return Ok(());
9925 }
9926 depth.increment()?;
9927 let envelope_size = 8;
9928 let bytes_len = max_ordinal as usize * envelope_size;
9929 #[allow(unused_variables)]
9930 let offset = encoder.out_of_line_offset(bytes_len);
9931 let mut _prev_end_offset: usize = 0;
9932
9933 Ok(())
9934 }
9935 }
9936
9937 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VendorSpecific {
9938 #[inline(always)]
9939 fn new_empty() -> Self {
9940 Self::default()
9941 }
9942
9943 unsafe fn decode(
9944 &mut self,
9945 decoder: &mut fidl::encoding::Decoder<'_, D>,
9946 offset: usize,
9947 mut depth: fidl::encoding::Depth,
9948 ) -> fidl::Result<()> {
9949 decoder.debug_check_bounds::<Self>(offset);
9950 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9951 None => return Err(fidl::Error::NotNullable),
9952 Some(len) => len,
9953 };
9954 if len == 0 {
9956 return Ok(());
9957 };
9958 depth.increment()?;
9959 let envelope_size = 8;
9960 let bytes_len = len * envelope_size;
9961 let offset = decoder.out_of_line_offset(bytes_len)?;
9962 let mut _next_ordinal_to_read = 0;
9964 let mut next_offset = offset;
9965 let end_offset = offset + bytes_len;
9966
9967 while next_offset < end_offset {
9969 _next_ordinal_to_read += 1;
9970 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9971 next_offset += envelope_size;
9972 }
9973
9974 Ok(())
9975 }
9976 }
9977
9978 impl VendorSpecificState {
9979 #[inline(always)]
9980 fn max_ordinal_present(&self) -> u64 {
9981 0
9982 }
9983 }
9984
9985 impl fidl::encoding::ValueTypeMarker for VendorSpecificState {
9986 type Borrowed<'a> = &'a Self;
9987 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9988 value
9989 }
9990 }
9991
9992 unsafe impl fidl::encoding::TypeMarker for VendorSpecificState {
9993 type Owned = Self;
9994
9995 #[inline(always)]
9996 fn inline_align(_context: fidl::encoding::Context) -> usize {
9997 8
9998 }
9999
10000 #[inline(always)]
10001 fn inline_size(_context: fidl::encoding::Context) -> usize {
10002 16
10003 }
10004 }
10005
10006 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VendorSpecificState, D>
10007 for &VendorSpecificState
10008 {
10009 unsafe fn encode(
10010 self,
10011 encoder: &mut fidl::encoding::Encoder<'_, D>,
10012 offset: usize,
10013 mut depth: fidl::encoding::Depth,
10014 ) -> fidl::Result<()> {
10015 encoder.debug_check_bounds::<VendorSpecificState>(offset);
10016 let max_ordinal: u64 = self.max_ordinal_present();
10018 encoder.write_num(max_ordinal, offset);
10019 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10020 if max_ordinal == 0 {
10022 return Ok(());
10023 }
10024 depth.increment()?;
10025 let envelope_size = 8;
10026 let bytes_len = max_ordinal as usize * envelope_size;
10027 #[allow(unused_variables)]
10028 let offset = encoder.out_of_line_offset(bytes_len);
10029 let mut _prev_end_offset: usize = 0;
10030
10031 Ok(())
10032 }
10033 }
10034
10035 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VendorSpecificState {
10036 #[inline(always)]
10037 fn new_empty() -> Self {
10038 Self::default()
10039 }
10040
10041 unsafe fn decode(
10042 &mut self,
10043 decoder: &mut fidl::encoding::Decoder<'_, D>,
10044 offset: usize,
10045 mut depth: fidl::encoding::Depth,
10046 ) -> fidl::Result<()> {
10047 decoder.debug_check_bounds::<Self>(offset);
10048 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10049 None => return Err(fidl::Error::NotNullable),
10050 Some(len) => len,
10051 };
10052 if len == 0 {
10054 return Ok(());
10055 };
10056 depth.increment()?;
10057 let envelope_size = 8;
10058 let bytes_len = len * envelope_size;
10059 let offset = decoder.out_of_line_offset(bytes_len)?;
10060 let mut _next_ordinal_to_read = 0;
10062 let mut next_offset = offset;
10063 let end_offset = offset + bytes_len;
10064
10065 while next_offset < end_offset {
10067 _next_ordinal_to_read += 1;
10068 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10069 next_offset += envelope_size;
10070 }
10071
10072 Ok(())
10073 }
10074 }
10075
10076 impl fidl::encoding::ValueTypeMarker for Latency {
10077 type Borrowed<'a> = &'a Self;
10078 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10079 value
10080 }
10081 }
10082
10083 unsafe impl fidl::encoding::TypeMarker for Latency {
10084 type Owned = Self;
10085
10086 #[inline(always)]
10087 fn inline_align(_context: fidl::encoding::Context) -> usize {
10088 8
10089 }
10090
10091 #[inline(always)]
10092 fn inline_size(_context: fidl::encoding::Context) -> usize {
10093 16
10094 }
10095 }
10096
10097 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Latency, D> for &Latency {
10098 #[inline]
10099 unsafe fn encode(
10100 self,
10101 encoder: &mut fidl::encoding::Encoder<'_, D>,
10102 offset: usize,
10103 _depth: fidl::encoding::Depth,
10104 ) -> fidl::Result<()> {
10105 encoder.debug_check_bounds::<Latency>(offset);
10106 encoder.write_num::<u64>(self.ordinal(), offset);
10107 match self {
10108 Latency::LatencyTime(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
10109 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
10110 encoder,
10111 offset + 8,
10112 _depth,
10113 ),
10114 Latency::LatencyFrames(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
10115 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
10116 encoder,
10117 offset + 8,
10118 _depth,
10119 ),
10120 Latency::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10121 }
10122 }
10123 }
10124
10125 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Latency {
10126 #[inline(always)]
10127 fn new_empty() -> Self {
10128 Self::__SourceBreaking { unknown_ordinal: 0 }
10129 }
10130
10131 #[inline]
10132 unsafe fn decode(
10133 &mut self,
10134 decoder: &mut fidl::encoding::Decoder<'_, D>,
10135 offset: usize,
10136 mut depth: fidl::encoding::Depth,
10137 ) -> fidl::Result<()> {
10138 decoder.debug_check_bounds::<Self>(offset);
10139 #[allow(unused_variables)]
10140 let next_out_of_line = decoder.next_out_of_line();
10141 let handles_before = decoder.remaining_handles();
10142 let (ordinal, inlined, num_bytes, num_handles) =
10143 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10144
10145 let member_inline_size = match ordinal {
10146 1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10147 2 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10148 0 => return Err(fidl::Error::UnknownUnionTag),
10149 _ => num_bytes as usize,
10150 };
10151
10152 if inlined != (member_inline_size <= 4) {
10153 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10154 }
10155 let _inner_offset;
10156 if inlined {
10157 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10158 _inner_offset = offset + 8;
10159 } else {
10160 depth.increment()?;
10161 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10162 }
10163 match ordinal {
10164 1 => {
10165 #[allow(irrefutable_let_patterns)]
10166 if let Latency::LatencyTime(_) = self {
10167 } else {
10169 *self = Latency::LatencyTime(fidl::new_empty!(i64, D));
10171 }
10172 #[allow(irrefutable_let_patterns)]
10173 if let Latency::LatencyTime(ref mut val) = self {
10174 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
10175 } else {
10176 unreachable!()
10177 }
10178 }
10179 2 => {
10180 #[allow(irrefutable_let_patterns)]
10181 if let Latency::LatencyFrames(_) = self {
10182 } else {
10184 *self = Latency::LatencyFrames(fidl::new_empty!(u32, D));
10186 }
10187 #[allow(irrefutable_let_patterns)]
10188 if let Latency::LatencyFrames(ref mut val) = self {
10189 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
10190 } else {
10191 unreachable!()
10192 }
10193 }
10194 #[allow(deprecated)]
10195 ordinal => {
10196 for _ in 0..num_handles {
10197 decoder.drop_next_handle()?;
10198 }
10199 *self = Latency::__SourceBreaking { unknown_ordinal: ordinal };
10200 }
10201 }
10202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10203 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10204 }
10205 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10206 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10207 }
10208 Ok(())
10209 }
10210 }
10211
10212 impl fidl::encoding::ValueTypeMarker for SettableTypeSpecificElementState {
10213 type Borrowed<'a> = &'a Self;
10214 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10215 value
10216 }
10217 }
10218
10219 unsafe impl fidl::encoding::TypeMarker for SettableTypeSpecificElementState {
10220 type Owned = Self;
10221
10222 #[inline(always)]
10223 fn inline_align(_context: fidl::encoding::Context) -> usize {
10224 8
10225 }
10226
10227 #[inline(always)]
10228 fn inline_size(_context: fidl::encoding::Context) -> usize {
10229 16
10230 }
10231 }
10232
10233 unsafe impl<D: fidl::encoding::ResourceDialect>
10234 fidl::encoding::Encode<SettableTypeSpecificElementState, D>
10235 for &SettableTypeSpecificElementState
10236 {
10237 #[inline]
10238 unsafe fn encode(
10239 self,
10240 encoder: &mut fidl::encoding::Encoder<'_, D>,
10241 offset: usize,
10242 _depth: fidl::encoding::Depth,
10243 ) -> fidl::Result<()> {
10244 encoder.debug_check_bounds::<SettableTypeSpecificElementState>(offset);
10245 encoder.write_num::<u64>(self.ordinal(), offset);
10246 match self {
10247 SettableTypeSpecificElementState::VendorSpecific(ref val) => {
10248 fidl::encoding::encode_in_envelope::<VendorSpecificState, D>(
10249 <VendorSpecificState as fidl::encoding::ValueTypeMarker>::borrow(val),
10250 encoder,
10251 offset + 8,
10252 _depth,
10253 )
10254 }
10255 SettableTypeSpecificElementState::Gain(ref val) => {
10256 fidl::encoding::encode_in_envelope::<GainElementState, D>(
10257 <GainElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10258 encoder,
10259 offset + 8,
10260 _depth,
10261 )
10262 }
10263 SettableTypeSpecificElementState::Equalizer(ref val) => {
10264 fidl::encoding::encode_in_envelope::<EqualizerElementState, D>(
10265 <EqualizerElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10266 encoder,
10267 offset + 8,
10268 _depth,
10269 )
10270 }
10271 SettableTypeSpecificElementState::Dynamics(ref val) => {
10272 fidl::encoding::encode_in_envelope::<DynamicsElementState, D>(
10273 <DynamicsElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10274 encoder,
10275 offset + 8,
10276 _depth,
10277 )
10278 }
10279 SettableTypeSpecificElementState::__SourceBreaking { .. } => {
10280 Err(fidl::Error::UnknownUnionTag)
10281 }
10282 }
10283 }
10284 }
10285
10286 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10287 for SettableTypeSpecificElementState
10288 {
10289 #[inline(always)]
10290 fn new_empty() -> Self {
10291 Self::__SourceBreaking { unknown_ordinal: 0 }
10292 }
10293
10294 #[inline]
10295 unsafe fn decode(
10296 &mut self,
10297 decoder: &mut fidl::encoding::Decoder<'_, D>,
10298 offset: usize,
10299 mut depth: fidl::encoding::Depth,
10300 ) -> fidl::Result<()> {
10301 decoder.debug_check_bounds::<Self>(offset);
10302 #[allow(unused_variables)]
10303 let next_out_of_line = decoder.next_out_of_line();
10304 let handles_before = decoder.remaining_handles();
10305 let (ordinal, inlined, num_bytes, num_handles) =
10306 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10307
10308 let member_inline_size = match ordinal {
10309 1 => <VendorSpecificState as fidl::encoding::TypeMarker>::inline_size(
10310 decoder.context,
10311 ),
10312 2 => <GainElementState as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10313 3 => <EqualizerElementState as fidl::encoding::TypeMarker>::inline_size(
10314 decoder.context,
10315 ),
10316 4 => <DynamicsElementState as fidl::encoding::TypeMarker>::inline_size(
10317 decoder.context,
10318 ),
10319 0 => return Err(fidl::Error::UnknownUnionTag),
10320 _ => num_bytes as usize,
10321 };
10322
10323 if inlined != (member_inline_size <= 4) {
10324 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10325 }
10326 let _inner_offset;
10327 if inlined {
10328 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10329 _inner_offset = offset + 8;
10330 } else {
10331 depth.increment()?;
10332 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10333 }
10334 match ordinal {
10335 1 => {
10336 #[allow(irrefutable_let_patterns)]
10337 if let SettableTypeSpecificElementState::VendorSpecific(_) = self {
10338 } else {
10340 *self = SettableTypeSpecificElementState::VendorSpecific(fidl::new_empty!(
10342 VendorSpecificState,
10343 D
10344 ));
10345 }
10346 #[allow(irrefutable_let_patterns)]
10347 if let SettableTypeSpecificElementState::VendorSpecific(ref mut val) = self {
10348 fidl::decode!(VendorSpecificState, D, val, decoder, _inner_offset, depth)?;
10349 } else {
10350 unreachable!()
10351 }
10352 }
10353 2 => {
10354 #[allow(irrefutable_let_patterns)]
10355 if let SettableTypeSpecificElementState::Gain(_) = self {
10356 } else {
10358 *self = SettableTypeSpecificElementState::Gain(fidl::new_empty!(
10360 GainElementState,
10361 D
10362 ));
10363 }
10364 #[allow(irrefutable_let_patterns)]
10365 if let SettableTypeSpecificElementState::Gain(ref mut val) = self {
10366 fidl::decode!(GainElementState, D, val, decoder, _inner_offset, depth)?;
10367 } else {
10368 unreachable!()
10369 }
10370 }
10371 3 => {
10372 #[allow(irrefutable_let_patterns)]
10373 if let SettableTypeSpecificElementState::Equalizer(_) = self {
10374 } else {
10376 *self = SettableTypeSpecificElementState::Equalizer(fidl::new_empty!(
10378 EqualizerElementState,
10379 D
10380 ));
10381 }
10382 #[allow(irrefutable_let_patterns)]
10383 if let SettableTypeSpecificElementState::Equalizer(ref mut val) = self {
10384 fidl::decode!(
10385 EqualizerElementState,
10386 D,
10387 val,
10388 decoder,
10389 _inner_offset,
10390 depth
10391 )?;
10392 } else {
10393 unreachable!()
10394 }
10395 }
10396 4 => {
10397 #[allow(irrefutable_let_patterns)]
10398 if let SettableTypeSpecificElementState::Dynamics(_) = self {
10399 } else {
10401 *self = SettableTypeSpecificElementState::Dynamics(fidl::new_empty!(
10403 DynamicsElementState,
10404 D
10405 ));
10406 }
10407 #[allow(irrefutable_let_patterns)]
10408 if let SettableTypeSpecificElementState::Dynamics(ref mut val) = self {
10409 fidl::decode!(DynamicsElementState, D, val, decoder, _inner_offset, depth)?;
10410 } else {
10411 unreachable!()
10412 }
10413 }
10414 #[allow(deprecated)]
10415 ordinal => {
10416 for _ in 0..num_handles {
10417 decoder.drop_next_handle()?;
10418 }
10419 *self = SettableTypeSpecificElementState::__SourceBreaking {
10420 unknown_ordinal: ordinal,
10421 };
10422 }
10423 }
10424 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10425 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10426 }
10427 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10428 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10429 }
10430 Ok(())
10431 }
10432 }
10433
10434 impl fidl::encoding::ValueTypeMarker for TypeSpecificElement {
10435 type Borrowed<'a> = &'a Self;
10436 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10437 value
10438 }
10439 }
10440
10441 unsafe impl fidl::encoding::TypeMarker for TypeSpecificElement {
10442 type Owned = Self;
10443
10444 #[inline(always)]
10445 fn inline_align(_context: fidl::encoding::Context) -> usize {
10446 8
10447 }
10448
10449 #[inline(always)]
10450 fn inline_size(_context: fidl::encoding::Context) -> usize {
10451 16
10452 }
10453 }
10454
10455 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TypeSpecificElement, D>
10456 for &TypeSpecificElement
10457 {
10458 #[inline]
10459 unsafe fn encode(
10460 self,
10461 encoder: &mut fidl::encoding::Encoder<'_, D>,
10462 offset: usize,
10463 _depth: fidl::encoding::Depth,
10464 ) -> fidl::Result<()> {
10465 encoder.debug_check_bounds::<TypeSpecificElement>(offset);
10466 encoder.write_num::<u64>(self.ordinal(), offset);
10467 match self {
10468 TypeSpecificElement::VendorSpecific(ref val) => {
10469 fidl::encoding::encode_in_envelope::<VendorSpecific, D>(
10470 <VendorSpecific as fidl::encoding::ValueTypeMarker>::borrow(val),
10471 encoder,
10472 offset + 8,
10473 _depth,
10474 )
10475 }
10476 TypeSpecificElement::Gain(ref val) => {
10477 fidl::encoding::encode_in_envelope::<Gain, D>(
10478 <Gain as fidl::encoding::ValueTypeMarker>::borrow(val),
10479 encoder,
10480 offset + 8,
10481 _depth,
10482 )
10483 }
10484 TypeSpecificElement::Equalizer(ref val) => {
10485 fidl::encoding::encode_in_envelope::<Equalizer, D>(
10486 <Equalizer as fidl::encoding::ValueTypeMarker>::borrow(val),
10487 encoder,
10488 offset + 8,
10489 _depth,
10490 )
10491 }
10492 TypeSpecificElement::Dynamics(ref val) => {
10493 fidl::encoding::encode_in_envelope::<Dynamics, D>(
10494 <Dynamics as fidl::encoding::ValueTypeMarker>::borrow(val),
10495 encoder,
10496 offset + 8,
10497 _depth,
10498 )
10499 }
10500 TypeSpecificElement::Endpoint(ref val) => {
10501 fidl::encoding::encode_in_envelope::<Endpoint, D>(
10502 <Endpoint as fidl::encoding::ValueTypeMarker>::borrow(val),
10503 encoder,
10504 offset + 8,
10505 _depth,
10506 )
10507 }
10508 TypeSpecificElement::DaiInterconnect(ref val) => {
10509 fidl::encoding::encode_in_envelope::<DaiInterconnect, D>(
10510 <DaiInterconnect as fidl::encoding::ValueTypeMarker>::borrow(val),
10511 encoder,
10512 offset + 8,
10513 _depth,
10514 )
10515 }
10516 TypeSpecificElement::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10517 }
10518 }
10519 }
10520
10521 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TypeSpecificElement {
10522 #[inline(always)]
10523 fn new_empty() -> Self {
10524 Self::__SourceBreaking { unknown_ordinal: 0 }
10525 }
10526
10527 #[inline]
10528 unsafe fn decode(
10529 &mut self,
10530 decoder: &mut fidl::encoding::Decoder<'_, D>,
10531 offset: usize,
10532 mut depth: fidl::encoding::Depth,
10533 ) -> fidl::Result<()> {
10534 decoder.debug_check_bounds::<Self>(offset);
10535 #[allow(unused_variables)]
10536 let next_out_of_line = decoder.next_out_of_line();
10537 let handles_before = decoder.remaining_handles();
10538 let (ordinal, inlined, num_bytes, num_handles) =
10539 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10540
10541 let member_inline_size = match ordinal {
10542 1 => <VendorSpecific as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10543 2 => <Gain as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10544 3 => <Equalizer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10545 4 => <Dynamics as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10546 5 => <Endpoint as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10547 6 => <DaiInterconnect as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10548 0 => return Err(fidl::Error::UnknownUnionTag),
10549 _ => num_bytes as usize,
10550 };
10551
10552 if inlined != (member_inline_size <= 4) {
10553 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10554 }
10555 let _inner_offset;
10556 if inlined {
10557 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10558 _inner_offset = offset + 8;
10559 } else {
10560 depth.increment()?;
10561 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10562 }
10563 match ordinal {
10564 1 => {
10565 #[allow(irrefutable_let_patterns)]
10566 if let TypeSpecificElement::VendorSpecific(_) = self {
10567 } else {
10569 *self = TypeSpecificElement::VendorSpecific(fidl::new_empty!(
10571 VendorSpecific,
10572 D
10573 ));
10574 }
10575 #[allow(irrefutable_let_patterns)]
10576 if let TypeSpecificElement::VendorSpecific(ref mut val) = self {
10577 fidl::decode!(VendorSpecific, D, val, decoder, _inner_offset, depth)?;
10578 } else {
10579 unreachable!()
10580 }
10581 }
10582 2 => {
10583 #[allow(irrefutable_let_patterns)]
10584 if let TypeSpecificElement::Gain(_) = self {
10585 } else {
10587 *self = TypeSpecificElement::Gain(fidl::new_empty!(Gain, D));
10589 }
10590 #[allow(irrefutable_let_patterns)]
10591 if let TypeSpecificElement::Gain(ref mut val) = self {
10592 fidl::decode!(Gain, D, val, decoder, _inner_offset, depth)?;
10593 } else {
10594 unreachable!()
10595 }
10596 }
10597 3 => {
10598 #[allow(irrefutable_let_patterns)]
10599 if let TypeSpecificElement::Equalizer(_) = self {
10600 } else {
10602 *self = TypeSpecificElement::Equalizer(fidl::new_empty!(Equalizer, D));
10604 }
10605 #[allow(irrefutable_let_patterns)]
10606 if let TypeSpecificElement::Equalizer(ref mut val) = self {
10607 fidl::decode!(Equalizer, D, val, decoder, _inner_offset, depth)?;
10608 } else {
10609 unreachable!()
10610 }
10611 }
10612 4 => {
10613 #[allow(irrefutable_let_patterns)]
10614 if let TypeSpecificElement::Dynamics(_) = self {
10615 } else {
10617 *self = TypeSpecificElement::Dynamics(fidl::new_empty!(Dynamics, D));
10619 }
10620 #[allow(irrefutable_let_patterns)]
10621 if let TypeSpecificElement::Dynamics(ref mut val) = self {
10622 fidl::decode!(Dynamics, D, val, decoder, _inner_offset, depth)?;
10623 } else {
10624 unreachable!()
10625 }
10626 }
10627 5 => {
10628 #[allow(irrefutable_let_patterns)]
10629 if let TypeSpecificElement::Endpoint(_) = self {
10630 } else {
10632 *self = TypeSpecificElement::Endpoint(fidl::new_empty!(Endpoint, D));
10634 }
10635 #[allow(irrefutable_let_patterns)]
10636 if let TypeSpecificElement::Endpoint(ref mut val) = self {
10637 fidl::decode!(Endpoint, D, val, decoder, _inner_offset, depth)?;
10638 } else {
10639 unreachable!()
10640 }
10641 }
10642 6 => {
10643 #[allow(irrefutable_let_patterns)]
10644 if let TypeSpecificElement::DaiInterconnect(_) = self {
10645 } else {
10647 *self = TypeSpecificElement::DaiInterconnect(fidl::new_empty!(
10649 DaiInterconnect,
10650 D
10651 ));
10652 }
10653 #[allow(irrefutable_let_patterns)]
10654 if let TypeSpecificElement::DaiInterconnect(ref mut val) = self {
10655 fidl::decode!(DaiInterconnect, D, val, decoder, _inner_offset, depth)?;
10656 } else {
10657 unreachable!()
10658 }
10659 }
10660 #[allow(deprecated)]
10661 ordinal => {
10662 for _ in 0..num_handles {
10663 decoder.drop_next_handle()?;
10664 }
10665 *self = TypeSpecificElement::__SourceBreaking { unknown_ordinal: ordinal };
10666 }
10667 }
10668 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10669 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10670 }
10671 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10672 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10673 }
10674 Ok(())
10675 }
10676 }
10677
10678 impl fidl::encoding::ValueTypeMarker for TypeSpecificElementState {
10679 type Borrowed<'a> = &'a Self;
10680 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10681 value
10682 }
10683 }
10684
10685 unsafe impl fidl::encoding::TypeMarker for TypeSpecificElementState {
10686 type Owned = Self;
10687
10688 #[inline(always)]
10689 fn inline_align(_context: fidl::encoding::Context) -> usize {
10690 8
10691 }
10692
10693 #[inline(always)]
10694 fn inline_size(_context: fidl::encoding::Context) -> usize {
10695 16
10696 }
10697 }
10698
10699 unsafe impl<D: fidl::encoding::ResourceDialect>
10700 fidl::encoding::Encode<TypeSpecificElementState, D> for &TypeSpecificElementState
10701 {
10702 #[inline]
10703 unsafe fn encode(
10704 self,
10705 encoder: &mut fidl::encoding::Encoder<'_, D>,
10706 offset: usize,
10707 _depth: fidl::encoding::Depth,
10708 ) -> fidl::Result<()> {
10709 encoder.debug_check_bounds::<TypeSpecificElementState>(offset);
10710 encoder.write_num::<u64>(self.ordinal(), offset);
10711 match self {
10712 TypeSpecificElementState::VendorSpecific(ref val) => {
10713 fidl::encoding::encode_in_envelope::<VendorSpecificState, D>(
10714 <VendorSpecificState as fidl::encoding::ValueTypeMarker>::borrow(val),
10715 encoder,
10716 offset + 8,
10717 _depth,
10718 )
10719 }
10720 TypeSpecificElementState::Gain(ref val) => {
10721 fidl::encoding::encode_in_envelope::<GainElementState, D>(
10722 <GainElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10723 encoder,
10724 offset + 8,
10725 _depth,
10726 )
10727 }
10728 TypeSpecificElementState::Equalizer(ref val) => {
10729 fidl::encoding::encode_in_envelope::<EqualizerElementState, D>(
10730 <EqualizerElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10731 encoder,
10732 offset + 8,
10733 _depth,
10734 )
10735 }
10736 TypeSpecificElementState::Dynamics(ref val) => {
10737 fidl::encoding::encode_in_envelope::<DynamicsElementState, D>(
10738 <DynamicsElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10739 encoder,
10740 offset + 8,
10741 _depth,
10742 )
10743 }
10744 TypeSpecificElementState::Endpoint(ref val) => {
10745 fidl::encoding::encode_in_envelope::<EndpointElementState, D>(
10746 <EndpointElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10747 encoder,
10748 offset + 8,
10749 _depth,
10750 )
10751 }
10752 TypeSpecificElementState::DaiInterconnect(ref val) => {
10753 fidl::encoding::encode_in_envelope::<DaiInterconnectElementState, D>(
10754 <DaiInterconnectElementState as fidl::encoding::ValueTypeMarker>::borrow(
10755 val,
10756 ),
10757 encoder,
10758 offset + 8,
10759 _depth,
10760 )
10761 }
10762 TypeSpecificElementState::__SourceBreaking { .. } => {
10763 Err(fidl::Error::UnknownUnionTag)
10764 }
10765 }
10766 }
10767 }
10768
10769 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10770 for TypeSpecificElementState
10771 {
10772 #[inline(always)]
10773 fn new_empty() -> Self {
10774 Self::__SourceBreaking { unknown_ordinal: 0 }
10775 }
10776
10777 #[inline]
10778 unsafe fn decode(
10779 &mut self,
10780 decoder: &mut fidl::encoding::Decoder<'_, D>,
10781 offset: usize,
10782 mut depth: fidl::encoding::Depth,
10783 ) -> fidl::Result<()> {
10784 decoder.debug_check_bounds::<Self>(offset);
10785 #[allow(unused_variables)]
10786 let next_out_of_line = decoder.next_out_of_line();
10787 let handles_before = decoder.remaining_handles();
10788 let (ordinal, inlined, num_bytes, num_handles) =
10789 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10790
10791 let member_inline_size = match ordinal {
10792 1 => <VendorSpecificState as fidl::encoding::TypeMarker>::inline_size(
10793 decoder.context,
10794 ),
10795 2 => <GainElementState as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10796 3 => <EqualizerElementState as fidl::encoding::TypeMarker>::inline_size(
10797 decoder.context,
10798 ),
10799 4 => <DynamicsElementState as fidl::encoding::TypeMarker>::inline_size(
10800 decoder.context,
10801 ),
10802 5 => <EndpointElementState as fidl::encoding::TypeMarker>::inline_size(
10803 decoder.context,
10804 ),
10805 6 => <DaiInterconnectElementState as fidl::encoding::TypeMarker>::inline_size(
10806 decoder.context,
10807 ),
10808 0 => return Err(fidl::Error::UnknownUnionTag),
10809 _ => num_bytes as usize,
10810 };
10811
10812 if inlined != (member_inline_size <= 4) {
10813 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10814 }
10815 let _inner_offset;
10816 if inlined {
10817 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10818 _inner_offset = offset + 8;
10819 } else {
10820 depth.increment()?;
10821 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10822 }
10823 match ordinal {
10824 1 => {
10825 #[allow(irrefutable_let_patterns)]
10826 if let TypeSpecificElementState::VendorSpecific(_) = self {
10827 } else {
10829 *self = TypeSpecificElementState::VendorSpecific(fidl::new_empty!(
10831 VendorSpecificState,
10832 D
10833 ));
10834 }
10835 #[allow(irrefutable_let_patterns)]
10836 if let TypeSpecificElementState::VendorSpecific(ref mut val) = self {
10837 fidl::decode!(VendorSpecificState, D, val, decoder, _inner_offset, depth)?;
10838 } else {
10839 unreachable!()
10840 }
10841 }
10842 2 => {
10843 #[allow(irrefutable_let_patterns)]
10844 if let TypeSpecificElementState::Gain(_) = self {
10845 } else {
10847 *self =
10849 TypeSpecificElementState::Gain(fidl::new_empty!(GainElementState, D));
10850 }
10851 #[allow(irrefutable_let_patterns)]
10852 if let TypeSpecificElementState::Gain(ref mut val) = self {
10853 fidl::decode!(GainElementState, D, val, decoder, _inner_offset, depth)?;
10854 } else {
10855 unreachable!()
10856 }
10857 }
10858 3 => {
10859 #[allow(irrefutable_let_patterns)]
10860 if let TypeSpecificElementState::Equalizer(_) = self {
10861 } else {
10863 *self = TypeSpecificElementState::Equalizer(fidl::new_empty!(
10865 EqualizerElementState,
10866 D
10867 ));
10868 }
10869 #[allow(irrefutable_let_patterns)]
10870 if let TypeSpecificElementState::Equalizer(ref mut val) = self {
10871 fidl::decode!(
10872 EqualizerElementState,
10873 D,
10874 val,
10875 decoder,
10876 _inner_offset,
10877 depth
10878 )?;
10879 } else {
10880 unreachable!()
10881 }
10882 }
10883 4 => {
10884 #[allow(irrefutable_let_patterns)]
10885 if let TypeSpecificElementState::Dynamics(_) = self {
10886 } else {
10888 *self = TypeSpecificElementState::Dynamics(fidl::new_empty!(
10890 DynamicsElementState,
10891 D
10892 ));
10893 }
10894 #[allow(irrefutable_let_patterns)]
10895 if let TypeSpecificElementState::Dynamics(ref mut val) = self {
10896 fidl::decode!(DynamicsElementState, D, val, decoder, _inner_offset, depth)?;
10897 } else {
10898 unreachable!()
10899 }
10900 }
10901 5 => {
10902 #[allow(irrefutable_let_patterns)]
10903 if let TypeSpecificElementState::Endpoint(_) = self {
10904 } else {
10906 *self = TypeSpecificElementState::Endpoint(fidl::new_empty!(
10908 EndpointElementState,
10909 D
10910 ));
10911 }
10912 #[allow(irrefutable_let_patterns)]
10913 if let TypeSpecificElementState::Endpoint(ref mut val) = self {
10914 fidl::decode!(EndpointElementState, D, val, decoder, _inner_offset, depth)?;
10915 } else {
10916 unreachable!()
10917 }
10918 }
10919 6 => {
10920 #[allow(irrefutable_let_patterns)]
10921 if let TypeSpecificElementState::DaiInterconnect(_) = self {
10922 } else {
10924 *self = TypeSpecificElementState::DaiInterconnect(fidl::new_empty!(
10926 DaiInterconnectElementState,
10927 D
10928 ));
10929 }
10930 #[allow(irrefutable_let_patterns)]
10931 if let TypeSpecificElementState::DaiInterconnect(ref mut val) = self {
10932 fidl::decode!(
10933 DaiInterconnectElementState,
10934 D,
10935 val,
10936 decoder,
10937 _inner_offset,
10938 depth
10939 )?;
10940 } else {
10941 unreachable!()
10942 }
10943 }
10944 #[allow(deprecated)]
10945 ordinal => {
10946 for _ in 0..num_handles {
10947 decoder.drop_next_handle()?;
10948 }
10949 *self = TypeSpecificElementState::__SourceBreaking { unknown_ordinal: ordinal };
10950 }
10951 }
10952 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10953 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10954 }
10955 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10956 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10957 }
10958 Ok(())
10959 }
10960 }
10961}