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 ClockDomain = u32;
13
14pub type ElementId = u64;
15
16pub type TokenId = u64;
17
18pub type TopologyId = u64;
19
20pub const DEFAULT_DAI_INTERCONNECT_ELEMENT_ID: u64 = 1;
24
25pub const MAX_COUNT_CHANNELS: u32 =
27 fidl_fuchsia_hardware_audio__common::MAX_COUNT_CHANNELS_IN_RING_BUFFER as u32;
28
29pub const MAX_COUNT_CHANNEL_SETS: u32 =
31 fidl_fuchsia_hardware_audio__common::MAX_COUNT_CHANNEL_SETS as u32;
32
33pub const MAX_COUNT_DAI_FORMATS: u32 =
34 fidl_fuchsia_hardware_audio__common::MAX_COUNT_DAI_FORMATS as u32;
35
36pub const MAX_COUNT_DEVICES: u32 = 256;
38
39pub const MAX_COUNT_FORMATS: u32 = fidl_fuchsia_hardware_audio__common::MAX_COUNT_FORMATS as u32;
41
42pub const MAX_COUNT_PROCESSING_ELEMENTS: u32 =
44 fidl_fuchsia_hardware_audio_signalprocessing__common::MAX_COUNT_PROCESSING_ELEMENTS as u32;
45
46pub const MAX_COUNT_RATES: u32 =
48 fidl_fuchsia_hardware_audio__common::MAX_COUNT_SUPPORTED_RATES as u32;
49
50pub const MAX_COUNT_SAMPLE_TYPES: u32 = 32;
52
53pub const MAX_STRING_SIZE: u32 = fidl_fuchsia_hardware_audio__common::MAX_UI_STRING_SIZE as u32;
55
56pub const UNIQUE_INSTANCE_ID_SIZE: u32 = fidl_fuchsia_hardware_audio__common::UNIQUE_ID_SIZE as u32;
58
59#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
61pub enum ControlCodecStartError {
62 DeviceError,
64 WrongDeviceType,
66 AlreadyPending,
68 DaiFormatNotSet,
70 AlreadyStarted,
72 Other,
74 #[doc(hidden)]
75 __SourceBreaking { unknown_ordinal: u32 },
76}
77
78#[macro_export]
80macro_rules! ControlCodecStartErrorUnknown {
81 () => {
82 _
83 };
84}
85
86impl ControlCodecStartError {
87 #[inline]
88 pub fn from_primitive(prim: u32) -> Option<Self> {
89 match prim {
90 1 => Some(Self::DeviceError),
91 2 => Some(Self::WrongDeviceType),
92 3 => Some(Self::AlreadyPending),
93 4 => Some(Self::DaiFormatNotSet),
94 5 => Some(Self::AlreadyStarted),
95 6 => Some(Self::Other),
96 _ => None,
97 }
98 }
99
100 #[inline]
101 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
102 match prim {
103 1 => Self::DeviceError,
104 2 => Self::WrongDeviceType,
105 3 => Self::AlreadyPending,
106 4 => Self::DaiFormatNotSet,
107 5 => Self::AlreadyStarted,
108 6 => Self::Other,
109 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
110 }
111 }
112
113 #[inline]
114 pub fn unknown() -> Self {
115 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
116 }
117
118 #[inline]
119 pub const fn into_primitive(self) -> u32 {
120 match self {
121 Self::DeviceError => 1,
122 Self::WrongDeviceType => 2,
123 Self::AlreadyPending => 3,
124 Self::DaiFormatNotSet => 4,
125 Self::AlreadyStarted => 5,
126 Self::Other => 6,
127 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
128 }
129 }
130
131 #[inline]
132 pub fn is_unknown(&self) -> bool {
133 match self {
134 Self::__SourceBreaking { unknown_ordinal: _ } => true,
135 _ => false,
136 }
137 }
138}
139
140#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
142pub enum ControlCodecStopError {
143 DeviceError,
145 WrongDeviceType,
147 AlreadyPending,
149 DaiFormatNotSet,
151 AlreadyStopped,
153 Other,
155 #[doc(hidden)]
156 __SourceBreaking { unknown_ordinal: u32 },
157}
158
159#[macro_export]
161macro_rules! ControlCodecStopErrorUnknown {
162 () => {
163 _
164 };
165}
166
167impl ControlCodecStopError {
168 #[inline]
169 pub fn from_primitive(prim: u32) -> Option<Self> {
170 match prim {
171 1 => Some(Self::DeviceError),
172 2 => Some(Self::WrongDeviceType),
173 3 => Some(Self::AlreadyPending),
174 4 => Some(Self::DaiFormatNotSet),
175 5 => Some(Self::AlreadyStopped),
176 6 => Some(Self::Other),
177 _ => None,
178 }
179 }
180
181 #[inline]
182 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
183 match prim {
184 1 => Self::DeviceError,
185 2 => Self::WrongDeviceType,
186 3 => Self::AlreadyPending,
187 4 => Self::DaiFormatNotSet,
188 5 => Self::AlreadyStopped,
189 6 => Self::Other,
190 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
191 }
192 }
193
194 #[inline]
195 pub fn unknown() -> Self {
196 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
197 }
198
199 #[inline]
200 pub const fn into_primitive(self) -> u32 {
201 match self {
202 Self::DeviceError => 1,
203 Self::WrongDeviceType => 2,
204 Self::AlreadyPending => 3,
205 Self::DaiFormatNotSet => 4,
206 Self::AlreadyStopped => 5,
207 Self::Other => 6,
208 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
209 }
210 }
211
212 #[inline]
213 pub fn is_unknown(&self) -> bool {
214 match self {
215 Self::__SourceBreaking { unknown_ordinal: _ } => true,
216 _ => false,
217 }
218 }
219}
220
221#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
223pub enum ControlCreateRingBufferError {
224 DeviceError,
226 WrongDeviceType,
228 AlreadyPending,
230 InvalidElementId,
232 InvalidOptions,
234 InvalidFormat,
236 InvalidMinBytes,
238 InvalidRingBuffer,
240 AlreadyAllocated,
242 FormatMismatch,
244 BadRingBufferOption,
246 Other,
248 #[doc(hidden)]
249 __SourceBreaking { unknown_ordinal: u32 },
250}
251
252#[macro_export]
254macro_rules! ControlCreateRingBufferErrorUnknown {
255 () => {
256 _
257 };
258}
259
260impl ControlCreateRingBufferError {
261 #[inline]
262 pub fn from_primitive(prim: u32) -> Option<Self> {
263 match prim {
264 1 => Some(Self::DeviceError),
265 2 => Some(Self::WrongDeviceType),
266 3 => Some(Self::AlreadyPending),
267 4 => Some(Self::InvalidElementId),
268 5 => Some(Self::InvalidOptions),
269 6 => Some(Self::InvalidFormat),
270 7 => Some(Self::InvalidMinBytes),
271 8 => Some(Self::InvalidRingBuffer),
272 9 => Some(Self::AlreadyAllocated),
273 10 => Some(Self::FormatMismatch),
274 11 => Some(Self::BadRingBufferOption),
275 12 => Some(Self::Other),
276 _ => None,
277 }
278 }
279
280 #[inline]
281 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
282 match prim {
283 1 => Self::DeviceError,
284 2 => Self::WrongDeviceType,
285 3 => Self::AlreadyPending,
286 4 => Self::InvalidElementId,
287 5 => Self::InvalidOptions,
288 6 => Self::InvalidFormat,
289 7 => Self::InvalidMinBytes,
290 8 => Self::InvalidRingBuffer,
291 9 => Self::AlreadyAllocated,
292 10 => Self::FormatMismatch,
293 11 => Self::BadRingBufferOption,
294 12 => Self::Other,
295 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
296 }
297 }
298
299 #[inline]
300 pub fn unknown() -> Self {
301 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
302 }
303
304 #[inline]
305 pub const fn into_primitive(self) -> u32 {
306 match self {
307 Self::DeviceError => 1,
308 Self::WrongDeviceType => 2,
309 Self::AlreadyPending => 3,
310 Self::InvalidElementId => 4,
311 Self::InvalidOptions => 5,
312 Self::InvalidFormat => 6,
313 Self::InvalidMinBytes => 7,
314 Self::InvalidRingBuffer => 8,
315 Self::AlreadyAllocated => 9,
316 Self::FormatMismatch => 10,
317 Self::BadRingBufferOption => 11,
318 Self::Other => 12,
319 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
320 }
321 }
322
323 #[inline]
324 pub fn is_unknown(&self) -> bool {
325 match self {
326 Self::__SourceBreaking { unknown_ordinal: _ } => true,
327 _ => false,
328 }
329 }
330}
331
332#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
334pub enum ControlCreatorError {
335 InvalidTokenId,
337 InvalidControl,
339 DeviceNotFound,
342 DeviceError,
344 AlreadyAllocated,
347 #[doc(hidden)]
348 __SourceBreaking { unknown_ordinal: u32 },
349}
350
351#[macro_export]
353macro_rules! ControlCreatorErrorUnknown {
354 () => {
355 _
356 };
357}
358
359impl ControlCreatorError {
360 #[inline]
361 pub fn from_primitive(prim: u32) -> Option<Self> {
362 match prim {
363 1 => Some(Self::InvalidTokenId),
364 2 => Some(Self::InvalidControl),
365 3 => Some(Self::DeviceNotFound),
366 4 => Some(Self::DeviceError),
367 5 => Some(Self::AlreadyAllocated),
368 _ => None,
369 }
370 }
371
372 #[inline]
373 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
374 match prim {
375 1 => Self::InvalidTokenId,
376 2 => Self::InvalidControl,
377 3 => Self::DeviceNotFound,
378 4 => Self::DeviceError,
379 5 => Self::AlreadyAllocated,
380 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
381 }
382 }
383
384 #[inline]
385 pub fn unknown() -> Self {
386 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
387 }
388
389 #[inline]
390 pub const fn into_primitive(self) -> u32 {
391 match self {
392 Self::InvalidTokenId => 1,
393 Self::InvalidControl => 2,
394 Self::DeviceNotFound => 3,
395 Self::DeviceError => 4,
396 Self::AlreadyAllocated => 5,
397 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
398 }
399 }
400
401 #[inline]
402 pub fn is_unknown(&self) -> bool {
403 match self {
404 Self::__SourceBreaking { unknown_ordinal: _ } => true,
405 _ => false,
406 }
407 }
408}
409
410#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
412pub enum ControlResetError {
413 DeviceError,
415 WrongDeviceType,
417 AlreadyPending,
419 #[doc(hidden)]
420 __SourceBreaking { unknown_ordinal: u32 },
421}
422
423#[macro_export]
425macro_rules! ControlResetErrorUnknown {
426 () => {
427 _
428 };
429}
430
431impl ControlResetError {
432 #[inline]
433 pub fn from_primitive(prim: u32) -> Option<Self> {
434 match prim {
435 1 => Some(Self::DeviceError),
436 2 => Some(Self::WrongDeviceType),
437 3 => Some(Self::AlreadyPending),
438 _ => None,
439 }
440 }
441
442 #[inline]
443 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
444 match prim {
445 1 => Self::DeviceError,
446 2 => Self::WrongDeviceType,
447 3 => Self::AlreadyPending,
448 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
449 }
450 }
451
452 #[inline]
453 pub fn unknown() -> Self {
454 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
455 }
456
457 #[inline]
458 pub const fn into_primitive(self) -> u32 {
459 match self {
460 Self::DeviceError => 1,
461 Self::WrongDeviceType => 2,
462 Self::AlreadyPending => 3,
463 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
464 }
465 }
466
467 #[inline]
468 pub fn is_unknown(&self) -> bool {
469 match self {
470 Self::__SourceBreaking { unknown_ordinal: _ } => true,
471 _ => false,
472 }
473 }
474}
475
476#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
478pub enum ControlSetDaiFormatError {
479 DeviceError,
481 WrongDeviceType,
483 AlreadyPending,
485 InvalidElementId,
487 InvalidDaiFormat,
489 FormatMismatch,
491 Other,
493 #[doc(hidden)]
494 __SourceBreaking { unknown_ordinal: u32 },
495}
496
497#[macro_export]
499macro_rules! ControlSetDaiFormatErrorUnknown {
500 () => {
501 _
502 };
503}
504
505impl ControlSetDaiFormatError {
506 #[inline]
507 pub fn from_primitive(prim: u32) -> Option<Self> {
508 match prim {
509 1 => Some(Self::DeviceError),
510 2 => Some(Self::WrongDeviceType),
511 3 => Some(Self::AlreadyPending),
512 4 => Some(Self::InvalidElementId),
513 5 => Some(Self::InvalidDaiFormat),
514 6 => Some(Self::FormatMismatch),
515 7 => Some(Self::Other),
516 _ => None,
517 }
518 }
519
520 #[inline]
521 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
522 match prim {
523 1 => Self::DeviceError,
524 2 => Self::WrongDeviceType,
525 3 => Self::AlreadyPending,
526 4 => Self::InvalidElementId,
527 5 => Self::InvalidDaiFormat,
528 6 => Self::FormatMismatch,
529 7 => Self::Other,
530 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
531 }
532 }
533
534 #[inline]
535 pub fn unknown() -> Self {
536 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
537 }
538
539 #[inline]
540 pub const fn into_primitive(self) -> u32 {
541 match self {
542 Self::DeviceError => 1,
543 Self::WrongDeviceType => 2,
544 Self::AlreadyPending => 3,
545 Self::InvalidElementId => 4,
546 Self::InvalidDaiFormat => 5,
547 Self::FormatMismatch => 6,
548 Self::Other => 7,
549 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
550 }
551 }
552
553 #[inline]
554 pub fn is_unknown(&self) -> bool {
555 match self {
556 Self::__SourceBreaking { unknown_ordinal: _ } => true,
557 _ => false,
558 }
559 }
560}
561
562#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
564pub enum DeviceType {
565 Codec,
567 Composite,
569 #[doc(hidden)]
570 __SourceBreaking { unknown_ordinal: u32 },
571}
572
573#[macro_export]
575macro_rules! DeviceTypeUnknown {
576 () => {
577 _
578 };
579}
580
581impl DeviceType {
582 #[inline]
583 pub fn from_primitive(prim: u32) -> Option<Self> {
584 match prim {
585 1 => Some(Self::Codec),
586 2 => Some(Self::Composite),
587 _ => None,
588 }
589 }
590
591 #[inline]
592 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
593 match prim {
594 1 => Self::Codec,
595 2 => Self::Composite,
596 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
597 }
598 }
599
600 #[inline]
601 pub fn unknown() -> Self {
602 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
603 }
604
605 #[inline]
606 pub const fn into_primitive(self) -> u32 {
607 match self {
608 Self::Codec => 1,
609 Self::Composite => 2,
610 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
611 }
612 }
613
614 #[inline]
615 pub fn is_unknown(&self) -> bool {
616 match self {
617 Self::__SourceBreaking { unknown_ordinal: _ } => true,
618 _ => false,
619 }
620 }
621}
622
623#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
625pub enum ObserverGetReferenceClockError {
626 DeviceError,
628 WrongDeviceType,
630 DeviceClockUnavailable,
632 #[doc(hidden)]
633 __SourceBreaking { unknown_ordinal: u32 },
634}
635
636#[macro_export]
638macro_rules! ObserverGetReferenceClockErrorUnknown {
639 () => {
640 _
641 };
642}
643
644impl ObserverGetReferenceClockError {
645 #[inline]
646 pub fn from_primitive(prim: u32) -> Option<Self> {
647 match prim {
648 1 => Some(Self::DeviceError),
649 2 => Some(Self::WrongDeviceType),
650 3 => Some(Self::DeviceClockUnavailable),
651 _ => None,
652 }
653 }
654
655 #[inline]
656 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
657 match prim {
658 1 => Self::DeviceError,
659 2 => Self::WrongDeviceType,
660 3 => Self::DeviceClockUnavailable,
661 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
662 }
663 }
664
665 #[inline]
666 pub fn unknown() -> Self {
667 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
668 }
669
670 #[inline]
671 pub const fn into_primitive(self) -> u32 {
672 match self {
673 Self::DeviceError => 1,
674 Self::WrongDeviceType => 2,
675 Self::DeviceClockUnavailable => 3,
676 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
677 }
678 }
679
680 #[inline]
681 pub fn is_unknown(&self) -> bool {
682 match self {
683 Self::__SourceBreaking { unknown_ordinal: _ } => true,
684 _ => false,
685 }
686 }
687}
688
689#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
691pub enum ObserverWatchPlugStateError {
692 DeviceError,
694 WrongDeviceType,
696 AlreadyPending,
698 #[doc(hidden)]
699 __SourceBreaking { unknown_ordinal: u32 },
700}
701
702#[macro_export]
704macro_rules! ObserverWatchPlugStateErrorUnknown {
705 () => {
706 _
707 };
708}
709
710impl ObserverWatchPlugStateError {
711 #[inline]
712 pub fn from_primitive(prim: u32) -> Option<Self> {
713 match prim {
714 1 => Some(Self::DeviceError),
715 2 => Some(Self::WrongDeviceType),
716 3 => Some(Self::AlreadyPending),
717 _ => None,
718 }
719 }
720
721 #[inline]
722 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
723 match prim {
724 1 => Self::DeviceError,
725 2 => Self::WrongDeviceType,
726 3 => Self::AlreadyPending,
727 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
728 }
729 }
730
731 #[inline]
732 pub fn unknown() -> Self {
733 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
734 }
735
736 #[inline]
737 pub const fn into_primitive(self) -> u32 {
738 match self {
739 Self::DeviceError => 1,
740 Self::WrongDeviceType => 2,
741 Self::AlreadyPending => 3,
742 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
743 }
744 }
745
746 #[inline]
747 pub fn is_unknown(&self) -> bool {
748 match self {
749 Self::__SourceBreaking { unknown_ordinal: _ } => true,
750 _ => false,
751 }
752 }
753}
754
755#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
757pub enum PlugDetectCapabilities {
758 Hardwired,
760 Pluggable,
762 #[doc(hidden)]
763 __SourceBreaking { unknown_ordinal: u32 },
764}
765
766#[macro_export]
768macro_rules! PlugDetectCapabilitiesUnknown {
769 () => {
770 _
771 };
772}
773
774impl PlugDetectCapabilities {
775 #[inline]
776 pub fn from_primitive(prim: u32) -> Option<Self> {
777 match prim {
778 0 => Some(Self::Hardwired),
779 1 => Some(Self::Pluggable),
780 _ => None,
781 }
782 }
783
784 #[inline]
785 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
786 match prim {
787 0 => Self::Hardwired,
788 1 => Self::Pluggable,
789 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
790 }
791 }
792
793 #[inline]
794 pub fn unknown() -> Self {
795 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
796 }
797
798 #[inline]
799 pub const fn into_primitive(self) -> u32 {
800 match self {
801 Self::Hardwired => 0,
802 Self::Pluggable => 1,
803 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
804 }
805 }
806
807 #[inline]
808 pub fn is_unknown(&self) -> bool {
809 match self {
810 Self::__SourceBreaking { unknown_ordinal: _ } => true,
811 _ => false,
812 }
813 }
814}
815
816#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
818pub enum PlugState {
819 Plugged,
821 Unplugged,
823 #[doc(hidden)]
824 __SourceBreaking { unknown_ordinal: u32 },
825}
826
827#[macro_export]
829macro_rules! PlugStateUnknown {
830 () => {
831 _
832 };
833}
834
835impl PlugState {
836 #[inline]
837 pub fn from_primitive(prim: u32) -> Option<Self> {
838 match prim {
839 1 => Some(Self::Plugged),
840 2 => Some(Self::Unplugged),
841 _ => None,
842 }
843 }
844
845 #[inline]
846 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
847 match prim {
848 1 => Self::Plugged,
849 2 => Self::Unplugged,
850 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
851 }
852 }
853
854 #[inline]
855 pub fn unknown() -> Self {
856 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
857 }
858
859 #[inline]
860 pub const fn into_primitive(self) -> u32 {
861 match self {
862 Self::Plugged => 1,
863 Self::Unplugged => 2,
864 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
865 }
866 }
867
868 #[inline]
869 pub fn is_unknown(&self) -> bool {
870 match self {
871 Self::__SourceBreaking { unknown_ordinal: _ } => true,
872 _ => false,
873 }
874 }
875}
876
877#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
879pub enum ProviderAddDeviceError {
880 InvalidName,
882 InvalidType,
884 InvalidDriverClient,
886 WrongClientType,
888 #[doc(hidden)]
889 __SourceBreaking { unknown_ordinal: u32 },
890}
891
892#[macro_export]
894macro_rules! ProviderAddDeviceErrorUnknown {
895 () => {
896 _
897 };
898}
899
900impl ProviderAddDeviceError {
901 #[inline]
902 pub fn from_primitive(prim: u32) -> Option<Self> {
903 match prim {
904 1 => Some(Self::InvalidName),
905 2 => Some(Self::InvalidType),
906 3 => Some(Self::InvalidDriverClient),
907 4 => Some(Self::WrongClientType),
908 _ => None,
909 }
910 }
911
912 #[inline]
913 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
914 match prim {
915 1 => Self::InvalidName,
916 2 => Self::InvalidType,
917 3 => Self::InvalidDriverClient,
918 4 => Self::WrongClientType,
919 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
920 }
921 }
922
923 #[inline]
924 pub fn unknown() -> Self {
925 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
926 }
927
928 #[inline]
929 pub const fn into_primitive(self) -> u32 {
930 match self {
931 Self::InvalidName => 1,
932 Self::InvalidType => 2,
933 Self::InvalidDriverClient => 3,
934 Self::WrongClientType => 4,
935 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
936 }
937 }
938
939 #[inline]
940 pub fn is_unknown(&self) -> bool {
941 match self {
942 Self::__SourceBreaking { unknown_ordinal: _ } => true,
943 _ => false,
944 }
945 }
946}
947
948#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
950pub enum RegistryCreateObserverError {
951 InvalidTokenId,
953 InvalidObserver,
955 DeviceNotFound,
958 DeviceError,
960 #[doc(hidden)]
961 __SourceBreaking { unknown_ordinal: u32 },
962}
963
964#[macro_export]
966macro_rules! RegistryCreateObserverErrorUnknown {
967 () => {
968 _
969 };
970}
971
972impl RegistryCreateObserverError {
973 #[inline]
974 pub fn from_primitive(prim: u32) -> Option<Self> {
975 match prim {
976 1 => Some(Self::InvalidTokenId),
977 2 => Some(Self::InvalidObserver),
978 3 => Some(Self::DeviceNotFound),
979 4 => Some(Self::DeviceError),
980 _ => None,
981 }
982 }
983
984 #[inline]
985 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
986 match prim {
987 1 => Self::InvalidTokenId,
988 2 => Self::InvalidObserver,
989 3 => Self::DeviceNotFound,
990 4 => Self::DeviceError,
991 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
992 }
993 }
994
995 #[inline]
996 pub fn unknown() -> Self {
997 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
998 }
999
1000 #[inline]
1001 pub const fn into_primitive(self) -> u32 {
1002 match self {
1003 Self::InvalidTokenId => 1,
1004 Self::InvalidObserver => 2,
1005 Self::DeviceNotFound => 3,
1006 Self::DeviceError => 4,
1007 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1008 }
1009 }
1010
1011 #[inline]
1012 pub fn is_unknown(&self) -> bool {
1013 match self {
1014 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1015 _ => false,
1016 }
1017 }
1018}
1019
1020#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1022pub enum RegistryWatchDeviceRemovedError {
1023 AlreadyPending,
1025 #[doc(hidden)]
1026 __SourceBreaking { unknown_ordinal: u32 },
1027}
1028
1029#[macro_export]
1031macro_rules! RegistryWatchDeviceRemovedErrorUnknown {
1032 () => {
1033 _
1034 };
1035}
1036
1037impl RegistryWatchDeviceRemovedError {
1038 #[inline]
1039 pub fn from_primitive(prim: u32) -> Option<Self> {
1040 match prim {
1041 1 => Some(Self::AlreadyPending),
1042 _ => None,
1043 }
1044 }
1045
1046 #[inline]
1047 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1048 match prim {
1049 1 => Self::AlreadyPending,
1050 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1051 }
1052 }
1053
1054 #[inline]
1055 pub fn unknown() -> Self {
1056 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1057 }
1058
1059 #[inline]
1060 pub const fn into_primitive(self) -> u32 {
1061 match self {
1062 Self::AlreadyPending => 1,
1063 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1064 }
1065 }
1066
1067 #[inline]
1068 pub fn is_unknown(&self) -> bool {
1069 match self {
1070 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1071 _ => false,
1072 }
1073 }
1074}
1075
1076#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1078pub enum RegistryWatchDevicesAddedError {
1079 AlreadyPending,
1081 #[doc(hidden)]
1082 __SourceBreaking { unknown_ordinal: u32 },
1083}
1084
1085#[macro_export]
1087macro_rules! RegistryWatchDevicesAddedErrorUnknown {
1088 () => {
1089 _
1090 };
1091}
1092
1093impl RegistryWatchDevicesAddedError {
1094 #[inline]
1095 pub fn from_primitive(prim: u32) -> Option<Self> {
1096 match prim {
1097 1 => Some(Self::AlreadyPending),
1098 _ => None,
1099 }
1100 }
1101
1102 #[inline]
1103 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1104 match prim {
1105 1 => Self::AlreadyPending,
1106 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1107 }
1108 }
1109
1110 #[inline]
1111 pub fn unknown() -> Self {
1112 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1113 }
1114
1115 #[inline]
1116 pub const fn into_primitive(self) -> u32 {
1117 match self {
1118 Self::AlreadyPending => 1,
1119 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1120 }
1121 }
1122
1123 #[inline]
1124 pub fn is_unknown(&self) -> bool {
1125 match self {
1126 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1127 _ => false,
1128 }
1129 }
1130}
1131
1132#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1134pub enum RingBufferSetActiveChannelsError {
1135 DeviceError,
1137 AlreadyPending,
1139 MethodNotSupported,
1142 InvalidChannelBitmask,
1144 ChannelOutOfRange,
1147 #[doc(hidden)]
1148 __SourceBreaking { unknown_ordinal: u32 },
1149}
1150
1151#[macro_export]
1153macro_rules! RingBufferSetActiveChannelsErrorUnknown {
1154 () => {
1155 _
1156 };
1157}
1158
1159impl RingBufferSetActiveChannelsError {
1160 #[inline]
1161 pub fn from_primitive(prim: u32) -> Option<Self> {
1162 match prim {
1163 1 => Some(Self::DeviceError),
1164 2 => Some(Self::AlreadyPending),
1165 3 => Some(Self::MethodNotSupported),
1166 4 => Some(Self::InvalidChannelBitmask),
1167 5 => Some(Self::ChannelOutOfRange),
1168 _ => None,
1169 }
1170 }
1171
1172 #[inline]
1173 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1174 match prim {
1175 1 => Self::DeviceError,
1176 2 => Self::AlreadyPending,
1177 3 => Self::MethodNotSupported,
1178 4 => Self::InvalidChannelBitmask,
1179 5 => Self::ChannelOutOfRange,
1180 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1181 }
1182 }
1183
1184 #[inline]
1185 pub fn unknown() -> Self {
1186 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1187 }
1188
1189 #[inline]
1190 pub const fn into_primitive(self) -> u32 {
1191 match self {
1192 Self::DeviceError => 1,
1193 Self::AlreadyPending => 2,
1194 Self::MethodNotSupported => 3,
1195 Self::InvalidChannelBitmask => 4,
1196 Self::ChannelOutOfRange => 5,
1197 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1198 }
1199 }
1200
1201 #[inline]
1202 pub fn is_unknown(&self) -> bool {
1203 match self {
1204 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1205 _ => false,
1206 }
1207 }
1208}
1209
1210#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1212pub enum RingBufferStartError {
1213 DeviceError,
1215 AlreadyPending,
1217 AlreadyStarted,
1219 #[doc(hidden)]
1220 __SourceBreaking { unknown_ordinal: u32 },
1221}
1222
1223#[macro_export]
1225macro_rules! RingBufferStartErrorUnknown {
1226 () => {
1227 _
1228 };
1229}
1230
1231impl RingBufferStartError {
1232 #[inline]
1233 pub fn from_primitive(prim: u32) -> Option<Self> {
1234 match prim {
1235 1 => Some(Self::DeviceError),
1236 2 => Some(Self::AlreadyPending),
1237 3 => Some(Self::AlreadyStarted),
1238 _ => None,
1239 }
1240 }
1241
1242 #[inline]
1243 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1244 match prim {
1245 1 => Self::DeviceError,
1246 2 => Self::AlreadyPending,
1247 3 => Self::AlreadyStarted,
1248 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1249 }
1250 }
1251
1252 #[inline]
1253 pub fn unknown() -> Self {
1254 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1255 }
1256
1257 #[inline]
1258 pub const fn into_primitive(self) -> u32 {
1259 match self {
1260 Self::DeviceError => 1,
1261 Self::AlreadyPending => 2,
1262 Self::AlreadyStarted => 3,
1263 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1264 }
1265 }
1266
1267 #[inline]
1268 pub fn is_unknown(&self) -> bool {
1269 match self {
1270 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1271 _ => false,
1272 }
1273 }
1274}
1275
1276#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1278pub enum RingBufferStopError {
1279 DeviceError,
1281 AlreadyPending,
1283 AlreadyStopped,
1285 #[doc(hidden)]
1286 __SourceBreaking { unknown_ordinal: u32 },
1287}
1288
1289#[macro_export]
1291macro_rules! RingBufferStopErrorUnknown {
1292 () => {
1293 _
1294 };
1295}
1296
1297impl RingBufferStopError {
1298 #[inline]
1299 pub fn from_primitive(prim: u32) -> Option<Self> {
1300 match prim {
1301 1 => Some(Self::DeviceError),
1302 2 => Some(Self::AlreadyPending),
1303 3 => Some(Self::AlreadyStopped),
1304 _ => None,
1305 }
1306 }
1307
1308 #[inline]
1309 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1310 match prim {
1311 1 => Self::DeviceError,
1312 2 => Self::AlreadyPending,
1313 3 => Self::AlreadyStopped,
1314 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1315 }
1316 }
1317
1318 #[inline]
1319 pub fn unknown() -> Self {
1320 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1321 }
1322
1323 #[inline]
1324 pub const fn into_primitive(self) -> u32 {
1325 match self {
1326 Self::DeviceError => 1,
1327 Self::AlreadyPending => 2,
1328 Self::AlreadyStopped => 3,
1329 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1330 }
1331 }
1332
1333 #[inline]
1334 pub fn is_unknown(&self) -> bool {
1335 match self {
1336 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1337 _ => false,
1338 }
1339 }
1340}
1341
1342#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1344pub enum RingBufferWatchDelayInfoError {
1345 DeviceError,
1347 AlreadyPending,
1349 #[doc(hidden)]
1350 __SourceBreaking { unknown_ordinal: u32 },
1351}
1352
1353#[macro_export]
1355macro_rules! RingBufferWatchDelayInfoErrorUnknown {
1356 () => {
1357 _
1358 };
1359}
1360
1361impl RingBufferWatchDelayInfoError {
1362 #[inline]
1363 pub fn from_primitive(prim: u32) -> Option<Self> {
1364 match prim {
1365 1 => Some(Self::DeviceError),
1366 2 => Some(Self::AlreadyPending),
1367 _ => None,
1368 }
1369 }
1370
1371 #[inline]
1372 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1373 match prim {
1374 1 => Self::DeviceError,
1375 2 => Self::AlreadyPending,
1376 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1377 }
1378 }
1379
1380 #[inline]
1381 pub fn unknown() -> Self {
1382 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1383 }
1384
1385 #[inline]
1386 pub const fn into_primitive(self) -> u32 {
1387 match self {
1388 Self::DeviceError => 1,
1389 Self::AlreadyPending => 2,
1390 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1391 }
1392 }
1393
1394 #[inline]
1395 pub fn is_unknown(&self) -> bool {
1396 match self {
1397 Self::__SourceBreaking { unknown_ordinal: _ } => true,
1398 _ => false,
1399 }
1400 }
1401}
1402
1403#[derive(Clone, Debug, Default, PartialEq)]
1405pub struct ChannelAttributes {
1406 pub min_frequency: Option<u32>,
1411 pub max_frequency: Option<u32>,
1416 #[doc(hidden)]
1417 pub __source_breaking: fidl::marker::SourceBreaking,
1418}
1419
1420impl fidl::Persistable for ChannelAttributes {}
1421
1422#[derive(Clone, Debug, Default, PartialEq)]
1424pub struct ChannelSet {
1425 pub attributes: Option<Vec<ChannelAttributes>>,
1431 #[doc(hidden)]
1432 pub __source_breaking: fidl::marker::SourceBreaking,
1433}
1434
1435impl fidl::Persistable for ChannelSet {}
1436
1437#[derive(Clone, Debug, Default, PartialEq)]
1438pub struct ControlCreatorCreateResponse {
1439 #[doc(hidden)]
1440 pub __source_breaking: fidl::marker::SourceBreaking,
1441}
1442
1443impl fidl::Persistable for ControlCreatorCreateResponse {}
1444
1445#[derive(Clone, Debug, Default, PartialEq)]
1446pub struct ControlSetDaiFormatRequest {
1447 pub element_id: Option<u64>,
1451 pub dai_format: Option<fidl_fuchsia_hardware_audio__common::DaiFormat>,
1452 #[doc(hidden)]
1453 pub __source_breaking: fidl::marker::SourceBreaking,
1454}
1455
1456impl fidl::Persistable for ControlSetDaiFormatRequest {}
1457
1458#[derive(Clone, Debug, Default, PartialEq)]
1459pub struct ControlCodecStartResponse {
1460 pub start_time: Option<i64>,
1461 #[doc(hidden)]
1462 pub __source_breaking: fidl::marker::SourceBreaking,
1463}
1464
1465impl fidl::Persistable for ControlCodecStartResponse {}
1466
1467#[derive(Clone, Debug, Default, PartialEq)]
1468pub struct ControlCodecStopResponse {
1469 pub stop_time: Option<i64>,
1470 #[doc(hidden)]
1471 pub __source_breaking: fidl::marker::SourceBreaking,
1472}
1473
1474impl fidl::Persistable for ControlCodecStopResponse {}
1475
1476#[derive(Clone, Debug, Default, PartialEq)]
1477pub struct ControlResetResponse {
1478 #[doc(hidden)]
1479 pub __source_breaking: fidl::marker::SourceBreaking,
1480}
1481
1482impl fidl::Persistable for ControlResetResponse {}
1483
1484#[derive(Clone, Debug, Default, PartialEq)]
1485pub struct ControlSetDaiFormatResponse {
1486 pub state: Option<fidl_fuchsia_hardware_audio__common::CodecFormatInfo>,
1487 #[doc(hidden)]
1488 pub __source_breaking: fidl::marker::SourceBreaking,
1489}
1490
1491impl fidl::Persistable for ControlSetDaiFormatResponse {}
1492
1493#[derive(Clone, Debug, Default, PartialEq)]
1494pub struct DelayInfo {
1495 pub internal_delay: Option<i64>,
1500 pub external_delay: Option<i64>,
1506 #[doc(hidden)]
1507 pub __source_breaking: fidl::marker::SourceBreaking,
1508}
1509
1510impl fidl::Persistable for DelayInfo {}
1511
1512#[derive(Clone, Debug, Default, PartialEq)]
1514pub struct ElementDaiFormatSet {
1515 pub element_id: Option<u64>,
1522 pub format_sets: Option<Vec<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats>>,
1526 #[doc(hidden)]
1527 pub __source_breaking: fidl::marker::SourceBreaking,
1528}
1529
1530impl fidl::Persistable for ElementDaiFormatSet {}
1531
1532#[derive(Clone, Debug, Default, PartialEq)]
1534pub struct ElementRingBufferFormatSet {
1535 pub element_id: Option<u64>,
1540 pub format_sets: Option<Vec<PcmFormatSet>>,
1544 #[doc(hidden)]
1545 pub __source_breaking: fidl::marker::SourceBreaking,
1546}
1547
1548impl fidl::Persistable for ElementRingBufferFormatSet {}
1549
1550#[derive(Clone, Debug, Default, PartialEq)]
1557pub struct Info {
1558 pub token_id: Option<u64>,
1563 pub device_type: Option<DeviceType>,
1567 pub device_name: Option<String>,
1572 pub manufacturer: Option<String>,
1577 pub product: Option<String>,
1582 pub unique_instance_id: Option<[u8; 16]>,
1588 pub is_input: Option<bool>,
1592 pub ring_buffer_format_sets: Option<Vec<ElementRingBufferFormatSet>>,
1602 pub dai_format_sets: Option<Vec<ElementDaiFormatSet>>,
1612 pub plug_detect_caps: Option<PlugDetectCapabilities>,
1616 pub clock_domain: Option<u32>,
1633 pub signal_processing_elements:
1638 Option<Vec<fidl_fuchsia_hardware_audio_signalprocessing__common::Element>>,
1639 pub signal_processing_topologies:
1644 Option<Vec<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology>>,
1645 #[doc(hidden)]
1646 pub __source_breaking: fidl::marker::SourceBreaking,
1647}
1648
1649impl fidl::Persistable for Info {}
1650
1651#[derive(Clone, Debug, Default, PartialEq)]
1652pub struct ObserverWatchPlugStateResponse {
1653 pub state: Option<PlugState>,
1655 pub plug_time: Option<i64>,
1657 #[doc(hidden)]
1658 pub __source_breaking: fidl::marker::SourceBreaking,
1659}
1660
1661impl fidl::Persistable for ObserverWatchPlugStateResponse {}
1662
1663#[derive(Clone, Debug, Default, PartialEq)]
1667pub struct PcmFormatSet {
1668 pub channel_sets: Option<Vec<ChannelSet>>,
1673 pub sample_types: Option<Vec<fidl_fuchsia_audio__common::SampleType>>,
1678 pub frame_rates: Option<Vec<u32>>,
1683 #[doc(hidden)]
1684 pub __source_breaking: fidl::marker::SourceBreaking,
1685}
1686
1687impl fidl::Persistable for PcmFormatSet {}
1688
1689#[derive(Clone, Debug, Default, PartialEq)]
1690pub struct ProviderAddDeviceResponse {
1691 #[doc(hidden)]
1692 pub __source_breaking: fidl::marker::SourceBreaking,
1693}
1694
1695impl fidl::Persistable for ProviderAddDeviceResponse {}
1696
1697#[derive(Clone, Debug, Default, PartialEq)]
1698pub struct RegistryCreateObserverResponse {
1699 #[doc(hidden)]
1700 pub __source_breaking: fidl::marker::SourceBreaking,
1701}
1702
1703impl fidl::Persistable for RegistryCreateObserverResponse {}
1704
1705#[derive(Clone, Debug, Default, PartialEq)]
1706pub struct RegistryWatchDeviceRemovedResponse {
1707 pub token_id: Option<u64>,
1709 #[doc(hidden)]
1710 pub __source_breaking: fidl::marker::SourceBreaking,
1711}
1712
1713impl fidl::Persistable for RegistryWatchDeviceRemovedResponse {}
1714
1715#[derive(Clone, Debug, Default, PartialEq)]
1716pub struct RegistryWatchDevicesAddedResponse {
1717 pub devices: Option<Vec<Info>>,
1722 #[doc(hidden)]
1723 pub __source_breaking: fidl::marker::SourceBreaking,
1724}
1725
1726impl fidl::Persistable for RegistryWatchDevicesAddedResponse {}
1727
1728#[derive(Clone, Debug, Default, PartialEq)]
1730pub struct RingBufferOptions {
1731 pub format: Option<fidl_fuchsia_audio__common::Format>,
1736 pub ring_buffer_min_bytes: Option<u32>,
1741 #[doc(hidden)]
1742 pub __source_breaking: fidl::marker::SourceBreaking,
1743}
1744
1745impl fidl::Persistable for RingBufferOptions {}
1746
1747#[derive(Clone, Debug, Default, PartialEq)]
1749pub struct RingBufferProperties {
1750 pub valid_bits_per_sample: Option<u8>,
1757 pub turn_on_delay: Option<i64>,
1763 #[doc(hidden)]
1764 pub __source_breaking: fidl::marker::SourceBreaking,
1765}
1766
1767impl fidl::Persistable for RingBufferProperties {}
1768
1769#[derive(Clone, Debug, Default, PartialEq)]
1770pub struct RingBufferSetActiveChannelsRequest {
1771 pub channel_bitmask: Option<u64>,
1778 #[doc(hidden)]
1779 pub __source_breaking: fidl::marker::SourceBreaking,
1780}
1781
1782impl fidl::Persistable for RingBufferSetActiveChannelsRequest {}
1783
1784#[derive(Clone, Debug, Default, PartialEq)]
1785pub struct RingBufferStartRequest {
1786 #[doc(hidden)]
1787 pub __source_breaking: fidl::marker::SourceBreaking,
1788}
1789
1790impl fidl::Persistable for RingBufferStartRequest {}
1791
1792#[derive(Clone, Debug, Default, PartialEq)]
1793pub struct RingBufferStopRequest {
1794 #[doc(hidden)]
1795 pub __source_breaking: fidl::marker::SourceBreaking,
1796}
1797
1798impl fidl::Persistable for RingBufferStopRequest {}
1799
1800#[derive(Clone, Debug, Default, PartialEq)]
1801pub struct RingBufferSetActiveChannelsResponse {
1802 pub set_time: Option<i64>,
1807 #[doc(hidden)]
1808 pub __source_breaking: fidl::marker::SourceBreaking,
1809}
1810
1811impl fidl::Persistable for RingBufferSetActiveChannelsResponse {}
1812
1813#[derive(Clone, Debug, Default, PartialEq)]
1814pub struct RingBufferStartResponse {
1815 pub start_time: Option<i64>,
1819 #[doc(hidden)]
1820 pub __source_breaking: fidl::marker::SourceBreaking,
1821}
1822
1823impl fidl::Persistable for RingBufferStartResponse {}
1824
1825#[derive(Clone, Debug, Default, PartialEq)]
1826pub struct RingBufferStopResponse {
1827 #[doc(hidden)]
1828 pub __source_breaking: fidl::marker::SourceBreaking,
1829}
1830
1831impl fidl::Persistable for RingBufferStopResponse {}
1832
1833#[derive(Clone, Debug, Default, PartialEq)]
1834pub struct RingBufferWatchDelayInfoResponse {
1835 pub delay_info: Option<DelayInfo>,
1837 #[doc(hidden)]
1838 pub __source_breaking: fidl::marker::SourceBreaking,
1839}
1840
1841impl fidl::Persistable for RingBufferWatchDelayInfoResponse {}
1842
1843pub mod control_ordinals {
1844 pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1845 pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1846 pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1847 pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1848 pub const SET_TOPOLOGY: u64 = 0x1d9a7f9b8fee790c;
1849 pub const SET_ELEMENT_STATE: u64 = 0x38c3b2d4bae698f4;
1850 pub const CREATE_RING_BUFFER: u64 = 0x7462941cedb333db;
1851 pub const SET_DAI_FORMAT: u64 = 0x1d84f5a456a92216;
1852 pub const CODEC_START: u64 = 0x2a90a9d2958b997b;
1853 pub const CODEC_STOP: u64 = 0x387297bb6bcad25f;
1854 pub const RESET: u64 = 0x49840db00a698996;
1855}
1856
1857pub mod control_creator_ordinals {
1858 pub const CREATE: u64 = 0x341bdc9f49103a31;
1859}
1860
1861pub mod observer_ordinals {
1862 pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1863 pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1864 pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1865 pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1866 pub const WATCH_PLUG_STATE: u64 = 0x6312bce495d2907a;
1867 pub const GET_REFERENCE_CLOCK: u64 = 0x3819c5e0f9574c39;
1868}
1869
1870pub mod provider_ordinals {
1871 pub const ADD_DEVICE: u64 = 0x685fdfd91937758b;
1872}
1873
1874pub mod registry_ordinals {
1875 pub const WATCH_DEVICES_ADDED: u64 = 0x562ca31f7c149def;
1876 pub const WATCH_DEVICE_REMOVED: u64 = 0x6e67aabc99a502af;
1877 pub const CREATE_OBSERVER: u64 = 0x577bc322eb8d2bd1;
1878}
1879
1880pub mod ring_buffer_ordinals {
1881 pub const SET_ACTIVE_CHANNELS: u64 = 0x4276c43e4a3b59ee;
1882 pub const START: u64 = 0x5365a8609dc2dc5;
1883 pub const STOP: u64 = 0x5a238810af11e6e1;
1884 pub const WATCH_DELAY_INFO: u64 = 0x6d1dc5a928f38ad6;
1885}
1886
1887mod internal {
1888 use super::*;
1889 unsafe impl fidl::encoding::TypeMarker for ControlCodecStartError {
1890 type Owned = Self;
1891
1892 #[inline(always)]
1893 fn inline_align(_context: fidl::encoding::Context) -> usize {
1894 std::mem::align_of::<u32>()
1895 }
1896
1897 #[inline(always)]
1898 fn inline_size(_context: fidl::encoding::Context) -> usize {
1899 std::mem::size_of::<u32>()
1900 }
1901
1902 #[inline(always)]
1903 fn encode_is_copy() -> bool {
1904 false
1905 }
1906
1907 #[inline(always)]
1908 fn decode_is_copy() -> bool {
1909 false
1910 }
1911 }
1912
1913 impl fidl::encoding::ValueTypeMarker for ControlCodecStartError {
1914 type Borrowed<'a> = Self;
1915 #[inline(always)]
1916 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1917 *value
1918 }
1919 }
1920
1921 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1922 for ControlCodecStartError
1923 {
1924 #[inline]
1925 unsafe fn encode(
1926 self,
1927 encoder: &mut fidl::encoding::Encoder<'_, D>,
1928 offset: usize,
1929 _depth: fidl::encoding::Depth,
1930 ) -> fidl::Result<()> {
1931 encoder.debug_check_bounds::<Self>(offset);
1932 encoder.write_num(self.into_primitive(), offset);
1933 Ok(())
1934 }
1935 }
1936
1937 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1938 for ControlCodecStartError
1939 {
1940 #[inline(always)]
1941 fn new_empty() -> Self {
1942 Self::unknown()
1943 }
1944
1945 #[inline]
1946 unsafe fn decode(
1947 &mut self,
1948 decoder: &mut fidl::encoding::Decoder<'_, D>,
1949 offset: usize,
1950 _depth: fidl::encoding::Depth,
1951 ) -> fidl::Result<()> {
1952 decoder.debug_check_bounds::<Self>(offset);
1953 let prim = decoder.read_num::<u32>(offset);
1954
1955 *self = Self::from_primitive_allow_unknown(prim);
1956 Ok(())
1957 }
1958 }
1959 unsafe impl fidl::encoding::TypeMarker for ControlCodecStopError {
1960 type Owned = Self;
1961
1962 #[inline(always)]
1963 fn inline_align(_context: fidl::encoding::Context) -> usize {
1964 std::mem::align_of::<u32>()
1965 }
1966
1967 #[inline(always)]
1968 fn inline_size(_context: fidl::encoding::Context) -> usize {
1969 std::mem::size_of::<u32>()
1970 }
1971
1972 #[inline(always)]
1973 fn encode_is_copy() -> bool {
1974 false
1975 }
1976
1977 #[inline(always)]
1978 fn decode_is_copy() -> bool {
1979 false
1980 }
1981 }
1982
1983 impl fidl::encoding::ValueTypeMarker for ControlCodecStopError {
1984 type Borrowed<'a> = Self;
1985 #[inline(always)]
1986 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1987 *value
1988 }
1989 }
1990
1991 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1992 for ControlCodecStopError
1993 {
1994 #[inline]
1995 unsafe fn encode(
1996 self,
1997 encoder: &mut fidl::encoding::Encoder<'_, D>,
1998 offset: usize,
1999 _depth: fidl::encoding::Depth,
2000 ) -> fidl::Result<()> {
2001 encoder.debug_check_bounds::<Self>(offset);
2002 encoder.write_num(self.into_primitive(), offset);
2003 Ok(())
2004 }
2005 }
2006
2007 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCodecStopError {
2008 #[inline(always)]
2009 fn new_empty() -> Self {
2010 Self::unknown()
2011 }
2012
2013 #[inline]
2014 unsafe fn decode(
2015 &mut self,
2016 decoder: &mut fidl::encoding::Decoder<'_, D>,
2017 offset: usize,
2018 _depth: fidl::encoding::Depth,
2019 ) -> fidl::Result<()> {
2020 decoder.debug_check_bounds::<Self>(offset);
2021 let prim = decoder.read_num::<u32>(offset);
2022
2023 *self = Self::from_primitive_allow_unknown(prim);
2024 Ok(())
2025 }
2026 }
2027 unsafe impl fidl::encoding::TypeMarker for ControlCreateRingBufferError {
2028 type Owned = Self;
2029
2030 #[inline(always)]
2031 fn inline_align(_context: fidl::encoding::Context) -> usize {
2032 std::mem::align_of::<u32>()
2033 }
2034
2035 #[inline(always)]
2036 fn inline_size(_context: fidl::encoding::Context) -> usize {
2037 std::mem::size_of::<u32>()
2038 }
2039
2040 #[inline(always)]
2041 fn encode_is_copy() -> bool {
2042 false
2043 }
2044
2045 #[inline(always)]
2046 fn decode_is_copy() -> bool {
2047 false
2048 }
2049 }
2050
2051 impl fidl::encoding::ValueTypeMarker for ControlCreateRingBufferError {
2052 type Borrowed<'a> = Self;
2053 #[inline(always)]
2054 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2055 *value
2056 }
2057 }
2058
2059 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2060 for ControlCreateRingBufferError
2061 {
2062 #[inline]
2063 unsafe fn encode(
2064 self,
2065 encoder: &mut fidl::encoding::Encoder<'_, D>,
2066 offset: usize,
2067 _depth: fidl::encoding::Depth,
2068 ) -> fidl::Result<()> {
2069 encoder.debug_check_bounds::<Self>(offset);
2070 encoder.write_num(self.into_primitive(), offset);
2071 Ok(())
2072 }
2073 }
2074
2075 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2076 for ControlCreateRingBufferError
2077 {
2078 #[inline(always)]
2079 fn new_empty() -> Self {
2080 Self::unknown()
2081 }
2082
2083 #[inline]
2084 unsafe fn decode(
2085 &mut self,
2086 decoder: &mut fidl::encoding::Decoder<'_, D>,
2087 offset: usize,
2088 _depth: fidl::encoding::Depth,
2089 ) -> fidl::Result<()> {
2090 decoder.debug_check_bounds::<Self>(offset);
2091 let prim = decoder.read_num::<u32>(offset);
2092
2093 *self = Self::from_primitive_allow_unknown(prim);
2094 Ok(())
2095 }
2096 }
2097 unsafe impl fidl::encoding::TypeMarker for ControlCreatorError {
2098 type Owned = Self;
2099
2100 #[inline(always)]
2101 fn inline_align(_context: fidl::encoding::Context) -> usize {
2102 std::mem::align_of::<u32>()
2103 }
2104
2105 #[inline(always)]
2106 fn inline_size(_context: fidl::encoding::Context) -> usize {
2107 std::mem::size_of::<u32>()
2108 }
2109
2110 #[inline(always)]
2111 fn encode_is_copy() -> bool {
2112 false
2113 }
2114
2115 #[inline(always)]
2116 fn decode_is_copy() -> bool {
2117 false
2118 }
2119 }
2120
2121 impl fidl::encoding::ValueTypeMarker for ControlCreatorError {
2122 type Borrowed<'a> = Self;
2123 #[inline(always)]
2124 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2125 *value
2126 }
2127 }
2128
2129 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2130 for ControlCreatorError
2131 {
2132 #[inline]
2133 unsafe fn encode(
2134 self,
2135 encoder: &mut fidl::encoding::Encoder<'_, D>,
2136 offset: usize,
2137 _depth: fidl::encoding::Depth,
2138 ) -> fidl::Result<()> {
2139 encoder.debug_check_bounds::<Self>(offset);
2140 encoder.write_num(self.into_primitive(), offset);
2141 Ok(())
2142 }
2143 }
2144
2145 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCreatorError {
2146 #[inline(always)]
2147 fn new_empty() -> Self {
2148 Self::unknown()
2149 }
2150
2151 #[inline]
2152 unsafe fn decode(
2153 &mut self,
2154 decoder: &mut fidl::encoding::Decoder<'_, D>,
2155 offset: usize,
2156 _depth: fidl::encoding::Depth,
2157 ) -> fidl::Result<()> {
2158 decoder.debug_check_bounds::<Self>(offset);
2159 let prim = decoder.read_num::<u32>(offset);
2160
2161 *self = Self::from_primitive_allow_unknown(prim);
2162 Ok(())
2163 }
2164 }
2165 unsafe impl fidl::encoding::TypeMarker for ControlResetError {
2166 type Owned = Self;
2167
2168 #[inline(always)]
2169 fn inline_align(_context: fidl::encoding::Context) -> usize {
2170 std::mem::align_of::<u32>()
2171 }
2172
2173 #[inline(always)]
2174 fn inline_size(_context: fidl::encoding::Context) -> usize {
2175 std::mem::size_of::<u32>()
2176 }
2177
2178 #[inline(always)]
2179 fn encode_is_copy() -> bool {
2180 false
2181 }
2182
2183 #[inline(always)]
2184 fn decode_is_copy() -> bool {
2185 false
2186 }
2187 }
2188
2189 impl fidl::encoding::ValueTypeMarker for ControlResetError {
2190 type Borrowed<'a> = Self;
2191 #[inline(always)]
2192 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2193 *value
2194 }
2195 }
2196
2197 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2198 for ControlResetError
2199 {
2200 #[inline]
2201 unsafe fn encode(
2202 self,
2203 encoder: &mut fidl::encoding::Encoder<'_, D>,
2204 offset: usize,
2205 _depth: fidl::encoding::Depth,
2206 ) -> fidl::Result<()> {
2207 encoder.debug_check_bounds::<Self>(offset);
2208 encoder.write_num(self.into_primitive(), offset);
2209 Ok(())
2210 }
2211 }
2212
2213 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetError {
2214 #[inline(always)]
2215 fn new_empty() -> Self {
2216 Self::unknown()
2217 }
2218
2219 #[inline]
2220 unsafe fn decode(
2221 &mut self,
2222 decoder: &mut fidl::encoding::Decoder<'_, D>,
2223 offset: usize,
2224 _depth: fidl::encoding::Depth,
2225 ) -> fidl::Result<()> {
2226 decoder.debug_check_bounds::<Self>(offset);
2227 let prim = decoder.read_num::<u32>(offset);
2228
2229 *self = Self::from_primitive_allow_unknown(prim);
2230 Ok(())
2231 }
2232 }
2233 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatError {
2234 type Owned = Self;
2235
2236 #[inline(always)]
2237 fn inline_align(_context: fidl::encoding::Context) -> usize {
2238 std::mem::align_of::<u32>()
2239 }
2240
2241 #[inline(always)]
2242 fn inline_size(_context: fidl::encoding::Context) -> usize {
2243 std::mem::size_of::<u32>()
2244 }
2245
2246 #[inline(always)]
2247 fn encode_is_copy() -> bool {
2248 false
2249 }
2250
2251 #[inline(always)]
2252 fn decode_is_copy() -> bool {
2253 false
2254 }
2255 }
2256
2257 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatError {
2258 type Borrowed<'a> = Self;
2259 #[inline(always)]
2260 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2261 *value
2262 }
2263 }
2264
2265 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2266 for ControlSetDaiFormatError
2267 {
2268 #[inline]
2269 unsafe fn encode(
2270 self,
2271 encoder: &mut fidl::encoding::Encoder<'_, D>,
2272 offset: usize,
2273 _depth: fidl::encoding::Depth,
2274 ) -> fidl::Result<()> {
2275 encoder.debug_check_bounds::<Self>(offset);
2276 encoder.write_num(self.into_primitive(), offset);
2277 Ok(())
2278 }
2279 }
2280
2281 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2282 for ControlSetDaiFormatError
2283 {
2284 #[inline(always)]
2285 fn new_empty() -> Self {
2286 Self::unknown()
2287 }
2288
2289 #[inline]
2290 unsafe fn decode(
2291 &mut self,
2292 decoder: &mut fidl::encoding::Decoder<'_, D>,
2293 offset: usize,
2294 _depth: fidl::encoding::Depth,
2295 ) -> fidl::Result<()> {
2296 decoder.debug_check_bounds::<Self>(offset);
2297 let prim = decoder.read_num::<u32>(offset);
2298
2299 *self = Self::from_primitive_allow_unknown(prim);
2300 Ok(())
2301 }
2302 }
2303 unsafe impl fidl::encoding::TypeMarker for DeviceType {
2304 type Owned = Self;
2305
2306 #[inline(always)]
2307 fn inline_align(_context: fidl::encoding::Context) -> usize {
2308 std::mem::align_of::<u32>()
2309 }
2310
2311 #[inline(always)]
2312 fn inline_size(_context: fidl::encoding::Context) -> usize {
2313 std::mem::size_of::<u32>()
2314 }
2315
2316 #[inline(always)]
2317 fn encode_is_copy() -> bool {
2318 false
2319 }
2320
2321 #[inline(always)]
2322 fn decode_is_copy() -> bool {
2323 false
2324 }
2325 }
2326
2327 impl fidl::encoding::ValueTypeMarker for DeviceType {
2328 type Borrowed<'a> = Self;
2329 #[inline(always)]
2330 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2331 *value
2332 }
2333 }
2334
2335 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
2336 #[inline]
2337 unsafe fn encode(
2338 self,
2339 encoder: &mut fidl::encoding::Encoder<'_, D>,
2340 offset: usize,
2341 _depth: fidl::encoding::Depth,
2342 ) -> fidl::Result<()> {
2343 encoder.debug_check_bounds::<Self>(offset);
2344 encoder.write_num(self.into_primitive(), offset);
2345 Ok(())
2346 }
2347 }
2348
2349 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
2350 #[inline(always)]
2351 fn new_empty() -> Self {
2352 Self::unknown()
2353 }
2354
2355 #[inline]
2356 unsafe fn decode(
2357 &mut self,
2358 decoder: &mut fidl::encoding::Decoder<'_, D>,
2359 offset: usize,
2360 _depth: fidl::encoding::Depth,
2361 ) -> fidl::Result<()> {
2362 decoder.debug_check_bounds::<Self>(offset);
2363 let prim = decoder.read_num::<u32>(offset);
2364
2365 *self = Self::from_primitive_allow_unknown(prim);
2366 Ok(())
2367 }
2368 }
2369 unsafe impl fidl::encoding::TypeMarker for ObserverGetReferenceClockError {
2370 type Owned = Self;
2371
2372 #[inline(always)]
2373 fn inline_align(_context: fidl::encoding::Context) -> usize {
2374 std::mem::align_of::<u32>()
2375 }
2376
2377 #[inline(always)]
2378 fn inline_size(_context: fidl::encoding::Context) -> usize {
2379 std::mem::size_of::<u32>()
2380 }
2381
2382 #[inline(always)]
2383 fn encode_is_copy() -> bool {
2384 false
2385 }
2386
2387 #[inline(always)]
2388 fn decode_is_copy() -> bool {
2389 false
2390 }
2391 }
2392
2393 impl fidl::encoding::ValueTypeMarker for ObserverGetReferenceClockError {
2394 type Borrowed<'a> = Self;
2395 #[inline(always)]
2396 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2397 *value
2398 }
2399 }
2400
2401 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2402 for ObserverGetReferenceClockError
2403 {
2404 #[inline]
2405 unsafe fn encode(
2406 self,
2407 encoder: &mut fidl::encoding::Encoder<'_, D>,
2408 offset: usize,
2409 _depth: fidl::encoding::Depth,
2410 ) -> fidl::Result<()> {
2411 encoder.debug_check_bounds::<Self>(offset);
2412 encoder.write_num(self.into_primitive(), offset);
2413 Ok(())
2414 }
2415 }
2416
2417 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2418 for ObserverGetReferenceClockError
2419 {
2420 #[inline(always)]
2421 fn new_empty() -> Self {
2422 Self::unknown()
2423 }
2424
2425 #[inline]
2426 unsafe fn decode(
2427 &mut self,
2428 decoder: &mut fidl::encoding::Decoder<'_, D>,
2429 offset: usize,
2430 _depth: fidl::encoding::Depth,
2431 ) -> fidl::Result<()> {
2432 decoder.debug_check_bounds::<Self>(offset);
2433 let prim = decoder.read_num::<u32>(offset);
2434
2435 *self = Self::from_primitive_allow_unknown(prim);
2436 Ok(())
2437 }
2438 }
2439 unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateError {
2440 type Owned = Self;
2441
2442 #[inline(always)]
2443 fn inline_align(_context: fidl::encoding::Context) -> usize {
2444 std::mem::align_of::<u32>()
2445 }
2446
2447 #[inline(always)]
2448 fn inline_size(_context: fidl::encoding::Context) -> usize {
2449 std::mem::size_of::<u32>()
2450 }
2451
2452 #[inline(always)]
2453 fn encode_is_copy() -> bool {
2454 false
2455 }
2456
2457 #[inline(always)]
2458 fn decode_is_copy() -> bool {
2459 false
2460 }
2461 }
2462
2463 impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateError {
2464 type Borrowed<'a> = Self;
2465 #[inline(always)]
2466 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2467 *value
2468 }
2469 }
2470
2471 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2472 for ObserverWatchPlugStateError
2473 {
2474 #[inline]
2475 unsafe fn encode(
2476 self,
2477 encoder: &mut fidl::encoding::Encoder<'_, D>,
2478 offset: usize,
2479 _depth: fidl::encoding::Depth,
2480 ) -> fidl::Result<()> {
2481 encoder.debug_check_bounds::<Self>(offset);
2482 encoder.write_num(self.into_primitive(), offset);
2483 Ok(())
2484 }
2485 }
2486
2487 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2488 for ObserverWatchPlugStateError
2489 {
2490 #[inline(always)]
2491 fn new_empty() -> Self {
2492 Self::unknown()
2493 }
2494
2495 #[inline]
2496 unsafe fn decode(
2497 &mut self,
2498 decoder: &mut fidl::encoding::Decoder<'_, D>,
2499 offset: usize,
2500 _depth: fidl::encoding::Depth,
2501 ) -> fidl::Result<()> {
2502 decoder.debug_check_bounds::<Self>(offset);
2503 let prim = decoder.read_num::<u32>(offset);
2504
2505 *self = Self::from_primitive_allow_unknown(prim);
2506 Ok(())
2507 }
2508 }
2509 unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2510 type Owned = Self;
2511
2512 #[inline(always)]
2513 fn inline_align(_context: fidl::encoding::Context) -> usize {
2514 std::mem::align_of::<u32>()
2515 }
2516
2517 #[inline(always)]
2518 fn inline_size(_context: fidl::encoding::Context) -> usize {
2519 std::mem::size_of::<u32>()
2520 }
2521
2522 #[inline(always)]
2523 fn encode_is_copy() -> bool {
2524 false
2525 }
2526
2527 #[inline(always)]
2528 fn decode_is_copy() -> bool {
2529 false
2530 }
2531 }
2532
2533 impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2534 type Borrowed<'a> = Self;
2535 #[inline(always)]
2536 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2537 *value
2538 }
2539 }
2540
2541 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2542 for PlugDetectCapabilities
2543 {
2544 #[inline]
2545 unsafe fn encode(
2546 self,
2547 encoder: &mut fidl::encoding::Encoder<'_, D>,
2548 offset: usize,
2549 _depth: fidl::encoding::Depth,
2550 ) -> fidl::Result<()> {
2551 encoder.debug_check_bounds::<Self>(offset);
2552 encoder.write_num(self.into_primitive(), offset);
2553 Ok(())
2554 }
2555 }
2556
2557 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2558 for PlugDetectCapabilities
2559 {
2560 #[inline(always)]
2561 fn new_empty() -> Self {
2562 Self::unknown()
2563 }
2564
2565 #[inline]
2566 unsafe fn decode(
2567 &mut self,
2568 decoder: &mut fidl::encoding::Decoder<'_, D>,
2569 offset: usize,
2570 _depth: fidl::encoding::Depth,
2571 ) -> fidl::Result<()> {
2572 decoder.debug_check_bounds::<Self>(offset);
2573 let prim = decoder.read_num::<u32>(offset);
2574
2575 *self = Self::from_primitive_allow_unknown(prim);
2576 Ok(())
2577 }
2578 }
2579 unsafe impl fidl::encoding::TypeMarker for PlugState {
2580 type Owned = Self;
2581
2582 #[inline(always)]
2583 fn inline_align(_context: fidl::encoding::Context) -> usize {
2584 std::mem::align_of::<u32>()
2585 }
2586
2587 #[inline(always)]
2588 fn inline_size(_context: fidl::encoding::Context) -> usize {
2589 std::mem::size_of::<u32>()
2590 }
2591
2592 #[inline(always)]
2593 fn encode_is_copy() -> bool {
2594 false
2595 }
2596
2597 #[inline(always)]
2598 fn decode_is_copy() -> bool {
2599 false
2600 }
2601 }
2602
2603 impl fidl::encoding::ValueTypeMarker for PlugState {
2604 type Borrowed<'a> = Self;
2605 #[inline(always)]
2606 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2607 *value
2608 }
2609 }
2610
2611 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlugState {
2612 #[inline]
2613 unsafe fn encode(
2614 self,
2615 encoder: &mut fidl::encoding::Encoder<'_, D>,
2616 offset: usize,
2617 _depth: fidl::encoding::Depth,
2618 ) -> fidl::Result<()> {
2619 encoder.debug_check_bounds::<Self>(offset);
2620 encoder.write_num(self.into_primitive(), offset);
2621 Ok(())
2622 }
2623 }
2624
2625 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
2626 #[inline(always)]
2627 fn new_empty() -> Self {
2628 Self::unknown()
2629 }
2630
2631 #[inline]
2632 unsafe fn decode(
2633 &mut self,
2634 decoder: &mut fidl::encoding::Decoder<'_, D>,
2635 offset: usize,
2636 _depth: fidl::encoding::Depth,
2637 ) -> fidl::Result<()> {
2638 decoder.debug_check_bounds::<Self>(offset);
2639 let prim = decoder.read_num::<u32>(offset);
2640
2641 *self = Self::from_primitive_allow_unknown(prim);
2642 Ok(())
2643 }
2644 }
2645 unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceError {
2646 type Owned = Self;
2647
2648 #[inline(always)]
2649 fn inline_align(_context: fidl::encoding::Context) -> usize {
2650 std::mem::align_of::<u32>()
2651 }
2652
2653 #[inline(always)]
2654 fn inline_size(_context: fidl::encoding::Context) -> usize {
2655 std::mem::size_of::<u32>()
2656 }
2657
2658 #[inline(always)]
2659 fn encode_is_copy() -> bool {
2660 false
2661 }
2662
2663 #[inline(always)]
2664 fn decode_is_copy() -> bool {
2665 false
2666 }
2667 }
2668
2669 impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceError {
2670 type Borrowed<'a> = Self;
2671 #[inline(always)]
2672 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2673 *value
2674 }
2675 }
2676
2677 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2678 for ProviderAddDeviceError
2679 {
2680 #[inline]
2681 unsafe fn encode(
2682 self,
2683 encoder: &mut fidl::encoding::Encoder<'_, D>,
2684 offset: usize,
2685 _depth: fidl::encoding::Depth,
2686 ) -> fidl::Result<()> {
2687 encoder.debug_check_bounds::<Self>(offset);
2688 encoder.write_num(self.into_primitive(), offset);
2689 Ok(())
2690 }
2691 }
2692
2693 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2694 for ProviderAddDeviceError
2695 {
2696 #[inline(always)]
2697 fn new_empty() -> Self {
2698 Self::unknown()
2699 }
2700
2701 #[inline]
2702 unsafe fn decode(
2703 &mut self,
2704 decoder: &mut fidl::encoding::Decoder<'_, D>,
2705 offset: usize,
2706 _depth: fidl::encoding::Depth,
2707 ) -> fidl::Result<()> {
2708 decoder.debug_check_bounds::<Self>(offset);
2709 let prim = decoder.read_num::<u32>(offset);
2710
2711 *self = Self::from_primitive_allow_unknown(prim);
2712 Ok(())
2713 }
2714 }
2715 unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverError {
2716 type Owned = Self;
2717
2718 #[inline(always)]
2719 fn inline_align(_context: fidl::encoding::Context) -> usize {
2720 std::mem::align_of::<u32>()
2721 }
2722
2723 #[inline(always)]
2724 fn inline_size(_context: fidl::encoding::Context) -> usize {
2725 std::mem::size_of::<u32>()
2726 }
2727
2728 #[inline(always)]
2729 fn encode_is_copy() -> bool {
2730 false
2731 }
2732
2733 #[inline(always)]
2734 fn decode_is_copy() -> bool {
2735 false
2736 }
2737 }
2738
2739 impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverError {
2740 type Borrowed<'a> = Self;
2741 #[inline(always)]
2742 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2743 *value
2744 }
2745 }
2746
2747 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2748 for RegistryCreateObserverError
2749 {
2750 #[inline]
2751 unsafe fn encode(
2752 self,
2753 encoder: &mut fidl::encoding::Encoder<'_, D>,
2754 offset: usize,
2755 _depth: fidl::encoding::Depth,
2756 ) -> fidl::Result<()> {
2757 encoder.debug_check_bounds::<Self>(offset);
2758 encoder.write_num(self.into_primitive(), offset);
2759 Ok(())
2760 }
2761 }
2762
2763 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2764 for RegistryCreateObserverError
2765 {
2766 #[inline(always)]
2767 fn new_empty() -> Self {
2768 Self::unknown()
2769 }
2770
2771 #[inline]
2772 unsafe fn decode(
2773 &mut self,
2774 decoder: &mut fidl::encoding::Decoder<'_, D>,
2775 offset: usize,
2776 _depth: fidl::encoding::Depth,
2777 ) -> fidl::Result<()> {
2778 decoder.debug_check_bounds::<Self>(offset);
2779 let prim = decoder.read_num::<u32>(offset);
2780
2781 *self = Self::from_primitive_allow_unknown(prim);
2782 Ok(())
2783 }
2784 }
2785 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedError {
2786 type Owned = Self;
2787
2788 #[inline(always)]
2789 fn inline_align(_context: fidl::encoding::Context) -> usize {
2790 std::mem::align_of::<u32>()
2791 }
2792
2793 #[inline(always)]
2794 fn inline_size(_context: fidl::encoding::Context) -> usize {
2795 std::mem::size_of::<u32>()
2796 }
2797
2798 #[inline(always)]
2799 fn encode_is_copy() -> bool {
2800 false
2801 }
2802
2803 #[inline(always)]
2804 fn decode_is_copy() -> bool {
2805 false
2806 }
2807 }
2808
2809 impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedError {
2810 type Borrowed<'a> = Self;
2811 #[inline(always)]
2812 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2813 *value
2814 }
2815 }
2816
2817 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2818 for RegistryWatchDeviceRemovedError
2819 {
2820 #[inline]
2821 unsafe fn encode(
2822 self,
2823 encoder: &mut fidl::encoding::Encoder<'_, D>,
2824 offset: usize,
2825 _depth: fidl::encoding::Depth,
2826 ) -> fidl::Result<()> {
2827 encoder.debug_check_bounds::<Self>(offset);
2828 encoder.write_num(self.into_primitive(), offset);
2829 Ok(())
2830 }
2831 }
2832
2833 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2834 for RegistryWatchDeviceRemovedError
2835 {
2836 #[inline(always)]
2837 fn new_empty() -> Self {
2838 Self::unknown()
2839 }
2840
2841 #[inline]
2842 unsafe fn decode(
2843 &mut self,
2844 decoder: &mut fidl::encoding::Decoder<'_, D>,
2845 offset: usize,
2846 _depth: fidl::encoding::Depth,
2847 ) -> fidl::Result<()> {
2848 decoder.debug_check_bounds::<Self>(offset);
2849 let prim = decoder.read_num::<u32>(offset);
2850
2851 *self = Self::from_primitive_allow_unknown(prim);
2852 Ok(())
2853 }
2854 }
2855 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedError {
2856 type Owned = Self;
2857
2858 #[inline(always)]
2859 fn inline_align(_context: fidl::encoding::Context) -> usize {
2860 std::mem::align_of::<u32>()
2861 }
2862
2863 #[inline(always)]
2864 fn inline_size(_context: fidl::encoding::Context) -> usize {
2865 std::mem::size_of::<u32>()
2866 }
2867
2868 #[inline(always)]
2869 fn encode_is_copy() -> bool {
2870 false
2871 }
2872
2873 #[inline(always)]
2874 fn decode_is_copy() -> bool {
2875 false
2876 }
2877 }
2878
2879 impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedError {
2880 type Borrowed<'a> = Self;
2881 #[inline(always)]
2882 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2883 *value
2884 }
2885 }
2886
2887 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2888 for RegistryWatchDevicesAddedError
2889 {
2890 #[inline]
2891 unsafe fn encode(
2892 self,
2893 encoder: &mut fidl::encoding::Encoder<'_, D>,
2894 offset: usize,
2895 _depth: fidl::encoding::Depth,
2896 ) -> fidl::Result<()> {
2897 encoder.debug_check_bounds::<Self>(offset);
2898 encoder.write_num(self.into_primitive(), offset);
2899 Ok(())
2900 }
2901 }
2902
2903 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2904 for RegistryWatchDevicesAddedError
2905 {
2906 #[inline(always)]
2907 fn new_empty() -> Self {
2908 Self::unknown()
2909 }
2910
2911 #[inline]
2912 unsafe fn decode(
2913 &mut self,
2914 decoder: &mut fidl::encoding::Decoder<'_, D>,
2915 offset: usize,
2916 _depth: fidl::encoding::Depth,
2917 ) -> fidl::Result<()> {
2918 decoder.debug_check_bounds::<Self>(offset);
2919 let prim = decoder.read_num::<u32>(offset);
2920
2921 *self = Self::from_primitive_allow_unknown(prim);
2922 Ok(())
2923 }
2924 }
2925 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsError {
2926 type Owned = Self;
2927
2928 #[inline(always)]
2929 fn inline_align(_context: fidl::encoding::Context) -> usize {
2930 std::mem::align_of::<u32>()
2931 }
2932
2933 #[inline(always)]
2934 fn inline_size(_context: fidl::encoding::Context) -> usize {
2935 std::mem::size_of::<u32>()
2936 }
2937
2938 #[inline(always)]
2939 fn encode_is_copy() -> bool {
2940 false
2941 }
2942
2943 #[inline(always)]
2944 fn decode_is_copy() -> bool {
2945 false
2946 }
2947 }
2948
2949 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsError {
2950 type Borrowed<'a> = Self;
2951 #[inline(always)]
2952 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2953 *value
2954 }
2955 }
2956
2957 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2958 for RingBufferSetActiveChannelsError
2959 {
2960 #[inline]
2961 unsafe fn encode(
2962 self,
2963 encoder: &mut fidl::encoding::Encoder<'_, D>,
2964 offset: usize,
2965 _depth: fidl::encoding::Depth,
2966 ) -> fidl::Result<()> {
2967 encoder.debug_check_bounds::<Self>(offset);
2968 encoder.write_num(self.into_primitive(), offset);
2969 Ok(())
2970 }
2971 }
2972
2973 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2974 for RingBufferSetActiveChannelsError
2975 {
2976 #[inline(always)]
2977 fn new_empty() -> Self {
2978 Self::unknown()
2979 }
2980
2981 #[inline]
2982 unsafe fn decode(
2983 &mut self,
2984 decoder: &mut fidl::encoding::Decoder<'_, D>,
2985 offset: usize,
2986 _depth: fidl::encoding::Depth,
2987 ) -> fidl::Result<()> {
2988 decoder.debug_check_bounds::<Self>(offset);
2989 let prim = decoder.read_num::<u32>(offset);
2990
2991 *self = Self::from_primitive_allow_unknown(prim);
2992 Ok(())
2993 }
2994 }
2995 unsafe impl fidl::encoding::TypeMarker for RingBufferStartError {
2996 type Owned = Self;
2997
2998 #[inline(always)]
2999 fn inline_align(_context: fidl::encoding::Context) -> usize {
3000 std::mem::align_of::<u32>()
3001 }
3002
3003 #[inline(always)]
3004 fn inline_size(_context: fidl::encoding::Context) -> usize {
3005 std::mem::size_of::<u32>()
3006 }
3007
3008 #[inline(always)]
3009 fn encode_is_copy() -> bool {
3010 false
3011 }
3012
3013 #[inline(always)]
3014 fn decode_is_copy() -> bool {
3015 false
3016 }
3017 }
3018
3019 impl fidl::encoding::ValueTypeMarker for RingBufferStartError {
3020 type Borrowed<'a> = Self;
3021 #[inline(always)]
3022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3023 *value
3024 }
3025 }
3026
3027 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3028 for RingBufferStartError
3029 {
3030 #[inline]
3031 unsafe fn encode(
3032 self,
3033 encoder: &mut fidl::encoding::Encoder<'_, D>,
3034 offset: usize,
3035 _depth: fidl::encoding::Depth,
3036 ) -> fidl::Result<()> {
3037 encoder.debug_check_bounds::<Self>(offset);
3038 encoder.write_num(self.into_primitive(), offset);
3039 Ok(())
3040 }
3041 }
3042
3043 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStartError {
3044 #[inline(always)]
3045 fn new_empty() -> Self {
3046 Self::unknown()
3047 }
3048
3049 #[inline]
3050 unsafe fn decode(
3051 &mut self,
3052 decoder: &mut fidl::encoding::Decoder<'_, D>,
3053 offset: usize,
3054 _depth: fidl::encoding::Depth,
3055 ) -> fidl::Result<()> {
3056 decoder.debug_check_bounds::<Self>(offset);
3057 let prim = decoder.read_num::<u32>(offset);
3058
3059 *self = Self::from_primitive_allow_unknown(prim);
3060 Ok(())
3061 }
3062 }
3063 unsafe impl fidl::encoding::TypeMarker for RingBufferStopError {
3064 type Owned = Self;
3065
3066 #[inline(always)]
3067 fn inline_align(_context: fidl::encoding::Context) -> usize {
3068 std::mem::align_of::<u32>()
3069 }
3070
3071 #[inline(always)]
3072 fn inline_size(_context: fidl::encoding::Context) -> usize {
3073 std::mem::size_of::<u32>()
3074 }
3075
3076 #[inline(always)]
3077 fn encode_is_copy() -> bool {
3078 false
3079 }
3080
3081 #[inline(always)]
3082 fn decode_is_copy() -> bool {
3083 false
3084 }
3085 }
3086
3087 impl fidl::encoding::ValueTypeMarker for RingBufferStopError {
3088 type Borrowed<'a> = Self;
3089 #[inline(always)]
3090 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3091 *value
3092 }
3093 }
3094
3095 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3096 for RingBufferStopError
3097 {
3098 #[inline]
3099 unsafe fn encode(
3100 self,
3101 encoder: &mut fidl::encoding::Encoder<'_, D>,
3102 offset: usize,
3103 _depth: fidl::encoding::Depth,
3104 ) -> fidl::Result<()> {
3105 encoder.debug_check_bounds::<Self>(offset);
3106 encoder.write_num(self.into_primitive(), offset);
3107 Ok(())
3108 }
3109 }
3110
3111 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopError {
3112 #[inline(always)]
3113 fn new_empty() -> Self {
3114 Self::unknown()
3115 }
3116
3117 #[inline]
3118 unsafe fn decode(
3119 &mut self,
3120 decoder: &mut fidl::encoding::Decoder<'_, D>,
3121 offset: usize,
3122 _depth: fidl::encoding::Depth,
3123 ) -> fidl::Result<()> {
3124 decoder.debug_check_bounds::<Self>(offset);
3125 let prim = decoder.read_num::<u32>(offset);
3126
3127 *self = Self::from_primitive_allow_unknown(prim);
3128 Ok(())
3129 }
3130 }
3131 unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoError {
3132 type Owned = Self;
3133
3134 #[inline(always)]
3135 fn inline_align(_context: fidl::encoding::Context) -> usize {
3136 std::mem::align_of::<u32>()
3137 }
3138
3139 #[inline(always)]
3140 fn inline_size(_context: fidl::encoding::Context) -> usize {
3141 std::mem::size_of::<u32>()
3142 }
3143
3144 #[inline(always)]
3145 fn encode_is_copy() -> bool {
3146 false
3147 }
3148
3149 #[inline(always)]
3150 fn decode_is_copy() -> bool {
3151 false
3152 }
3153 }
3154
3155 impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoError {
3156 type Borrowed<'a> = Self;
3157 #[inline(always)]
3158 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3159 *value
3160 }
3161 }
3162
3163 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3164 for RingBufferWatchDelayInfoError
3165 {
3166 #[inline]
3167 unsafe fn encode(
3168 self,
3169 encoder: &mut fidl::encoding::Encoder<'_, D>,
3170 offset: usize,
3171 _depth: fidl::encoding::Depth,
3172 ) -> fidl::Result<()> {
3173 encoder.debug_check_bounds::<Self>(offset);
3174 encoder.write_num(self.into_primitive(), offset);
3175 Ok(())
3176 }
3177 }
3178
3179 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3180 for RingBufferWatchDelayInfoError
3181 {
3182 #[inline(always)]
3183 fn new_empty() -> Self {
3184 Self::unknown()
3185 }
3186
3187 #[inline]
3188 unsafe fn decode(
3189 &mut self,
3190 decoder: &mut fidl::encoding::Decoder<'_, D>,
3191 offset: usize,
3192 _depth: fidl::encoding::Depth,
3193 ) -> fidl::Result<()> {
3194 decoder.debug_check_bounds::<Self>(offset);
3195 let prim = decoder.read_num::<u32>(offset);
3196
3197 *self = Self::from_primitive_allow_unknown(prim);
3198 Ok(())
3199 }
3200 }
3201
3202 impl ChannelAttributes {
3203 #[inline(always)]
3204 fn max_ordinal_present(&self) -> u64 {
3205 if let Some(_) = self.max_frequency {
3206 return 2;
3207 }
3208 if let Some(_) = self.min_frequency {
3209 return 1;
3210 }
3211 0
3212 }
3213 }
3214
3215 impl fidl::encoding::ValueTypeMarker for ChannelAttributes {
3216 type Borrowed<'a> = &'a Self;
3217 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3218 value
3219 }
3220 }
3221
3222 unsafe impl fidl::encoding::TypeMarker for ChannelAttributes {
3223 type Owned = Self;
3224
3225 #[inline(always)]
3226 fn inline_align(_context: fidl::encoding::Context) -> usize {
3227 8
3228 }
3229
3230 #[inline(always)]
3231 fn inline_size(_context: fidl::encoding::Context) -> usize {
3232 16
3233 }
3234 }
3235
3236 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelAttributes, D>
3237 for &ChannelAttributes
3238 {
3239 unsafe fn encode(
3240 self,
3241 encoder: &mut fidl::encoding::Encoder<'_, D>,
3242 offset: usize,
3243 mut depth: fidl::encoding::Depth,
3244 ) -> fidl::Result<()> {
3245 encoder.debug_check_bounds::<ChannelAttributes>(offset);
3246 let max_ordinal: u64 = self.max_ordinal_present();
3248 encoder.write_num(max_ordinal, offset);
3249 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3250 if max_ordinal == 0 {
3252 return Ok(());
3253 }
3254 depth.increment()?;
3255 let envelope_size = 8;
3256 let bytes_len = max_ordinal as usize * envelope_size;
3257 #[allow(unused_variables)]
3258 let offset = encoder.out_of_line_offset(bytes_len);
3259 let mut _prev_end_offset: usize = 0;
3260 if 1 > max_ordinal {
3261 return Ok(());
3262 }
3263
3264 let cur_offset: usize = (1 - 1) * envelope_size;
3267
3268 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3270
3271 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3276 self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3277 encoder,
3278 offset + cur_offset,
3279 depth,
3280 )?;
3281
3282 _prev_end_offset = cur_offset + envelope_size;
3283 if 2 > max_ordinal {
3284 return Ok(());
3285 }
3286
3287 let cur_offset: usize = (2 - 1) * envelope_size;
3290
3291 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3293
3294 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3299 self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3300 encoder,
3301 offset + cur_offset,
3302 depth,
3303 )?;
3304
3305 _prev_end_offset = cur_offset + envelope_size;
3306
3307 Ok(())
3308 }
3309 }
3310
3311 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelAttributes {
3312 #[inline(always)]
3313 fn new_empty() -> Self {
3314 Self::default()
3315 }
3316
3317 unsafe fn decode(
3318 &mut self,
3319 decoder: &mut fidl::encoding::Decoder<'_, D>,
3320 offset: usize,
3321 mut depth: fidl::encoding::Depth,
3322 ) -> fidl::Result<()> {
3323 decoder.debug_check_bounds::<Self>(offset);
3324 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3325 None => return Err(fidl::Error::NotNullable),
3326 Some(len) => len,
3327 };
3328 if len == 0 {
3330 return Ok(());
3331 };
3332 depth.increment()?;
3333 let envelope_size = 8;
3334 let bytes_len = len * envelope_size;
3335 let offset = decoder.out_of_line_offset(bytes_len)?;
3336 let mut _next_ordinal_to_read = 0;
3338 let mut next_offset = offset;
3339 let end_offset = offset + bytes_len;
3340 _next_ordinal_to_read += 1;
3341 if next_offset >= end_offset {
3342 return Ok(());
3343 }
3344
3345 while _next_ordinal_to_read < 1 {
3347 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3348 _next_ordinal_to_read += 1;
3349 next_offset += envelope_size;
3350 }
3351
3352 let next_out_of_line = decoder.next_out_of_line();
3353 let handles_before = decoder.remaining_handles();
3354 if let Some((inlined, num_bytes, num_handles)) =
3355 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3356 {
3357 let member_inline_size =
3358 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3359 if inlined != (member_inline_size <= 4) {
3360 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3361 }
3362 let inner_offset;
3363 let mut inner_depth = depth.clone();
3364 if inlined {
3365 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3366 inner_offset = next_offset;
3367 } else {
3368 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3369 inner_depth.increment()?;
3370 }
3371 let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3372 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3373 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3374 {
3375 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3376 }
3377 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3378 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3379 }
3380 }
3381
3382 next_offset += envelope_size;
3383 _next_ordinal_to_read += 1;
3384 if next_offset >= end_offset {
3385 return Ok(());
3386 }
3387
3388 while _next_ordinal_to_read < 2 {
3390 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3391 _next_ordinal_to_read += 1;
3392 next_offset += envelope_size;
3393 }
3394
3395 let next_out_of_line = decoder.next_out_of_line();
3396 let handles_before = decoder.remaining_handles();
3397 if let Some((inlined, num_bytes, num_handles)) =
3398 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3399 {
3400 let member_inline_size =
3401 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3402 if inlined != (member_inline_size <= 4) {
3403 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3404 }
3405 let inner_offset;
3406 let mut inner_depth = depth.clone();
3407 if inlined {
3408 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3409 inner_offset = next_offset;
3410 } else {
3411 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3412 inner_depth.increment()?;
3413 }
3414 let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3415 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3416 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3417 {
3418 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3419 }
3420 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3421 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3422 }
3423 }
3424
3425 next_offset += envelope_size;
3426
3427 while next_offset < end_offset {
3429 _next_ordinal_to_read += 1;
3430 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3431 next_offset += envelope_size;
3432 }
3433
3434 Ok(())
3435 }
3436 }
3437
3438 impl ChannelSet {
3439 #[inline(always)]
3440 fn max_ordinal_present(&self) -> u64 {
3441 if let Some(_) = self.attributes {
3442 return 1;
3443 }
3444 0
3445 }
3446 }
3447
3448 impl fidl::encoding::ValueTypeMarker for ChannelSet {
3449 type Borrowed<'a> = &'a Self;
3450 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3451 value
3452 }
3453 }
3454
3455 unsafe impl fidl::encoding::TypeMarker for ChannelSet {
3456 type Owned = Self;
3457
3458 #[inline(always)]
3459 fn inline_align(_context: fidl::encoding::Context) -> usize {
3460 8
3461 }
3462
3463 #[inline(always)]
3464 fn inline_size(_context: fidl::encoding::Context) -> usize {
3465 16
3466 }
3467 }
3468
3469 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelSet, D>
3470 for &ChannelSet
3471 {
3472 unsafe fn encode(
3473 self,
3474 encoder: &mut fidl::encoding::Encoder<'_, D>,
3475 offset: usize,
3476 mut depth: fidl::encoding::Depth,
3477 ) -> fidl::Result<()> {
3478 encoder.debug_check_bounds::<ChannelSet>(offset);
3479 let max_ordinal: u64 = self.max_ordinal_present();
3481 encoder.write_num(max_ordinal, offset);
3482 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3483 if max_ordinal == 0 {
3485 return Ok(());
3486 }
3487 depth.increment()?;
3488 let envelope_size = 8;
3489 let bytes_len = max_ordinal as usize * envelope_size;
3490 #[allow(unused_variables)]
3491 let offset = encoder.out_of_line_offset(bytes_len);
3492 let mut _prev_end_offset: usize = 0;
3493 if 1 > max_ordinal {
3494 return Ok(());
3495 }
3496
3497 let cur_offset: usize = (1 - 1) * envelope_size;
3500
3501 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3503
3504 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelAttributes, 64>, D>(
3509 self.attributes.as_ref().map(<fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3510 encoder, offset + cur_offset, depth
3511 )?;
3512
3513 _prev_end_offset = cur_offset + envelope_size;
3514
3515 Ok(())
3516 }
3517 }
3518
3519 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelSet {
3520 #[inline(always)]
3521 fn new_empty() -> Self {
3522 Self::default()
3523 }
3524
3525 unsafe fn decode(
3526 &mut self,
3527 decoder: &mut fidl::encoding::Decoder<'_, D>,
3528 offset: usize,
3529 mut depth: fidl::encoding::Depth,
3530 ) -> fidl::Result<()> {
3531 decoder.debug_check_bounds::<Self>(offset);
3532 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3533 None => return Err(fidl::Error::NotNullable),
3534 Some(len) => len,
3535 };
3536 if len == 0 {
3538 return Ok(());
3539 };
3540 depth.increment()?;
3541 let envelope_size = 8;
3542 let bytes_len = len * envelope_size;
3543 let offset = decoder.out_of_line_offset(bytes_len)?;
3544 let mut _next_ordinal_to_read = 0;
3546 let mut next_offset = offset;
3547 let end_offset = offset + bytes_len;
3548 _next_ordinal_to_read += 1;
3549 if next_offset >= end_offset {
3550 return Ok(());
3551 }
3552
3553 while _next_ordinal_to_read < 1 {
3555 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3556 _next_ordinal_to_read += 1;
3557 next_offset += envelope_size;
3558 }
3559
3560 let next_out_of_line = decoder.next_out_of_line();
3561 let handles_before = decoder.remaining_handles();
3562 if let Some((inlined, num_bytes, num_handles)) =
3563 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3564 {
3565 let member_inline_size = <fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3566 if inlined != (member_inline_size <= 4) {
3567 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3568 }
3569 let inner_offset;
3570 let mut inner_depth = depth.clone();
3571 if inlined {
3572 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3573 inner_offset = next_offset;
3574 } else {
3575 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3576 inner_depth.increment()?;
3577 }
3578 let val_ref = self.attributes.get_or_insert_with(
3579 || fidl::new_empty!(fidl::encoding::Vector<ChannelAttributes, 64>, D),
3580 );
3581 fidl::decode!(fidl::encoding::Vector<ChannelAttributes, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3582 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3583 {
3584 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3585 }
3586 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3587 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3588 }
3589 }
3590
3591 next_offset += envelope_size;
3592
3593 while next_offset < end_offset {
3595 _next_ordinal_to_read += 1;
3596 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3597 next_offset += envelope_size;
3598 }
3599
3600 Ok(())
3601 }
3602 }
3603
3604 impl ControlCreatorCreateResponse {
3605 #[inline(always)]
3606 fn max_ordinal_present(&self) -> u64 {
3607 0
3608 }
3609 }
3610
3611 impl fidl::encoding::ValueTypeMarker for ControlCreatorCreateResponse {
3612 type Borrowed<'a> = &'a Self;
3613 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3614 value
3615 }
3616 }
3617
3618 unsafe impl fidl::encoding::TypeMarker for ControlCreatorCreateResponse {
3619 type Owned = Self;
3620
3621 #[inline(always)]
3622 fn inline_align(_context: fidl::encoding::Context) -> usize {
3623 8
3624 }
3625
3626 #[inline(always)]
3627 fn inline_size(_context: fidl::encoding::Context) -> usize {
3628 16
3629 }
3630 }
3631
3632 unsafe impl<D: fidl::encoding::ResourceDialect>
3633 fidl::encoding::Encode<ControlCreatorCreateResponse, D> for &ControlCreatorCreateResponse
3634 {
3635 unsafe fn encode(
3636 self,
3637 encoder: &mut fidl::encoding::Encoder<'_, D>,
3638 offset: usize,
3639 mut depth: fidl::encoding::Depth,
3640 ) -> fidl::Result<()> {
3641 encoder.debug_check_bounds::<ControlCreatorCreateResponse>(offset);
3642 let max_ordinal: u64 = self.max_ordinal_present();
3644 encoder.write_num(max_ordinal, offset);
3645 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3646 if max_ordinal == 0 {
3648 return Ok(());
3649 }
3650 depth.increment()?;
3651 let envelope_size = 8;
3652 let bytes_len = max_ordinal as usize * envelope_size;
3653 #[allow(unused_variables)]
3654 let offset = encoder.out_of_line_offset(bytes_len);
3655 let mut _prev_end_offset: usize = 0;
3656
3657 Ok(())
3658 }
3659 }
3660
3661 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3662 for ControlCreatorCreateResponse
3663 {
3664 #[inline(always)]
3665 fn new_empty() -> Self {
3666 Self::default()
3667 }
3668
3669 unsafe fn decode(
3670 &mut self,
3671 decoder: &mut fidl::encoding::Decoder<'_, D>,
3672 offset: usize,
3673 mut depth: fidl::encoding::Depth,
3674 ) -> fidl::Result<()> {
3675 decoder.debug_check_bounds::<Self>(offset);
3676 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3677 None => return Err(fidl::Error::NotNullable),
3678 Some(len) => len,
3679 };
3680 if len == 0 {
3682 return Ok(());
3683 };
3684 depth.increment()?;
3685 let envelope_size = 8;
3686 let bytes_len = len * envelope_size;
3687 let offset = decoder.out_of_line_offset(bytes_len)?;
3688 let mut _next_ordinal_to_read = 0;
3690 let mut next_offset = offset;
3691 let end_offset = offset + bytes_len;
3692
3693 while next_offset < end_offset {
3695 _next_ordinal_to_read += 1;
3696 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3697 next_offset += envelope_size;
3698 }
3699
3700 Ok(())
3701 }
3702 }
3703
3704 impl ControlSetDaiFormatRequest {
3705 #[inline(always)]
3706 fn max_ordinal_present(&self) -> u64 {
3707 if let Some(_) = self.dai_format {
3708 return 2;
3709 }
3710 if let Some(_) = self.element_id {
3711 return 1;
3712 }
3713 0
3714 }
3715 }
3716
3717 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatRequest {
3718 type Borrowed<'a> = &'a Self;
3719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3720 value
3721 }
3722 }
3723
3724 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatRequest {
3725 type Owned = Self;
3726
3727 #[inline(always)]
3728 fn inline_align(_context: fidl::encoding::Context) -> usize {
3729 8
3730 }
3731
3732 #[inline(always)]
3733 fn inline_size(_context: fidl::encoding::Context) -> usize {
3734 16
3735 }
3736 }
3737
3738 unsafe impl<D: fidl::encoding::ResourceDialect>
3739 fidl::encoding::Encode<ControlSetDaiFormatRequest, D> for &ControlSetDaiFormatRequest
3740 {
3741 unsafe fn encode(
3742 self,
3743 encoder: &mut fidl::encoding::Encoder<'_, D>,
3744 offset: usize,
3745 mut depth: fidl::encoding::Depth,
3746 ) -> fidl::Result<()> {
3747 encoder.debug_check_bounds::<ControlSetDaiFormatRequest>(offset);
3748 let max_ordinal: u64 = self.max_ordinal_present();
3750 encoder.write_num(max_ordinal, offset);
3751 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3752 if max_ordinal == 0 {
3754 return Ok(());
3755 }
3756 depth.increment()?;
3757 let envelope_size = 8;
3758 let bytes_len = max_ordinal as usize * envelope_size;
3759 #[allow(unused_variables)]
3760 let offset = encoder.out_of_line_offset(bytes_len);
3761 let mut _prev_end_offset: usize = 0;
3762 if 1 > max_ordinal {
3763 return Ok(());
3764 }
3765
3766 let cur_offset: usize = (1 - 1) * envelope_size;
3769
3770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3772
3773 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3778 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3779 encoder,
3780 offset + cur_offset,
3781 depth,
3782 )?;
3783
3784 _prev_end_offset = cur_offset + envelope_size;
3785 if 2 > max_ordinal {
3786 return Ok(());
3787 }
3788
3789 let cur_offset: usize = (2 - 1) * envelope_size;
3792
3793 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3795
3796 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::DaiFormat, D>(
3801 self.dai_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::ValueTypeMarker>::borrow),
3802 encoder, offset + cur_offset, depth
3803 )?;
3804
3805 _prev_end_offset = cur_offset + envelope_size;
3806
3807 Ok(())
3808 }
3809 }
3810
3811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3812 for ControlSetDaiFormatRequest
3813 {
3814 #[inline(always)]
3815 fn new_empty() -> Self {
3816 Self::default()
3817 }
3818
3819 unsafe fn decode(
3820 &mut self,
3821 decoder: &mut fidl::encoding::Decoder<'_, D>,
3822 offset: usize,
3823 mut depth: fidl::encoding::Depth,
3824 ) -> fidl::Result<()> {
3825 decoder.debug_check_bounds::<Self>(offset);
3826 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3827 None => return Err(fidl::Error::NotNullable),
3828 Some(len) => len,
3829 };
3830 if len == 0 {
3832 return Ok(());
3833 };
3834 depth.increment()?;
3835 let envelope_size = 8;
3836 let bytes_len = len * envelope_size;
3837 let offset = decoder.out_of_line_offset(bytes_len)?;
3838 let mut _next_ordinal_to_read = 0;
3840 let mut next_offset = offset;
3841 let end_offset = offset + bytes_len;
3842 _next_ordinal_to_read += 1;
3843 if next_offset >= end_offset {
3844 return Ok(());
3845 }
3846
3847 while _next_ordinal_to_read < 1 {
3849 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3850 _next_ordinal_to_read += 1;
3851 next_offset += envelope_size;
3852 }
3853
3854 let next_out_of_line = decoder.next_out_of_line();
3855 let handles_before = decoder.remaining_handles();
3856 if let Some((inlined, num_bytes, num_handles)) =
3857 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3858 {
3859 let member_inline_size =
3860 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3861 if inlined != (member_inline_size <= 4) {
3862 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3863 }
3864 let inner_offset;
3865 let mut inner_depth = depth.clone();
3866 if inlined {
3867 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3868 inner_offset = next_offset;
3869 } else {
3870 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3871 inner_depth.increment()?;
3872 }
3873 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3874 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3875 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3876 {
3877 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3878 }
3879 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3880 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3881 }
3882 }
3883
3884 next_offset += envelope_size;
3885 _next_ordinal_to_read += 1;
3886 if next_offset >= end_offset {
3887 return Ok(());
3888 }
3889
3890 while _next_ordinal_to_read < 2 {
3892 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3893 _next_ordinal_to_read += 1;
3894 next_offset += envelope_size;
3895 }
3896
3897 let next_out_of_line = decoder.next_out_of_line();
3898 let handles_before = decoder.remaining_handles();
3899 if let Some((inlined, num_bytes, num_handles)) =
3900 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3901 {
3902 let member_inline_size = <fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3903 if inlined != (member_inline_size <= 4) {
3904 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3905 }
3906 let inner_offset;
3907 let mut inner_depth = depth.clone();
3908 if inlined {
3909 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3910 inner_offset = next_offset;
3911 } else {
3912 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3913 inner_depth.increment()?;
3914 }
3915 let val_ref = self.dai_format.get_or_insert_with(|| {
3916 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::DaiFormat, D)
3917 });
3918 fidl::decode!(
3919 fidl_fuchsia_hardware_audio__common::DaiFormat,
3920 D,
3921 val_ref,
3922 decoder,
3923 inner_offset,
3924 inner_depth
3925 )?;
3926 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3927 {
3928 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3929 }
3930 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3931 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3932 }
3933 }
3934
3935 next_offset += envelope_size;
3936
3937 while next_offset < end_offset {
3939 _next_ordinal_to_read += 1;
3940 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3941 next_offset += envelope_size;
3942 }
3943
3944 Ok(())
3945 }
3946 }
3947
3948 impl ControlCodecStartResponse {
3949 #[inline(always)]
3950 fn max_ordinal_present(&self) -> u64 {
3951 if let Some(_) = self.start_time {
3952 return 1;
3953 }
3954 0
3955 }
3956 }
3957
3958 impl fidl::encoding::ValueTypeMarker for ControlCodecStartResponse {
3959 type Borrowed<'a> = &'a Self;
3960 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3961 value
3962 }
3963 }
3964
3965 unsafe impl fidl::encoding::TypeMarker for ControlCodecStartResponse {
3966 type Owned = Self;
3967
3968 #[inline(always)]
3969 fn inline_align(_context: fidl::encoding::Context) -> usize {
3970 8
3971 }
3972
3973 #[inline(always)]
3974 fn inline_size(_context: fidl::encoding::Context) -> usize {
3975 16
3976 }
3977 }
3978
3979 unsafe impl<D: fidl::encoding::ResourceDialect>
3980 fidl::encoding::Encode<ControlCodecStartResponse, D> for &ControlCodecStartResponse
3981 {
3982 unsafe fn encode(
3983 self,
3984 encoder: &mut fidl::encoding::Encoder<'_, D>,
3985 offset: usize,
3986 mut depth: fidl::encoding::Depth,
3987 ) -> fidl::Result<()> {
3988 encoder.debug_check_bounds::<ControlCodecStartResponse>(offset);
3989 let max_ordinal: u64 = self.max_ordinal_present();
3991 encoder.write_num(max_ordinal, offset);
3992 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3993 if max_ordinal == 0 {
3995 return Ok(());
3996 }
3997 depth.increment()?;
3998 let envelope_size = 8;
3999 let bytes_len = max_ordinal as usize * envelope_size;
4000 #[allow(unused_variables)]
4001 let offset = encoder.out_of_line_offset(bytes_len);
4002 let mut _prev_end_offset: usize = 0;
4003 if 1 > max_ordinal {
4004 return Ok(());
4005 }
4006
4007 let cur_offset: usize = (1 - 1) * envelope_size;
4010
4011 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4013
4014 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4019 self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4020 encoder,
4021 offset + cur_offset,
4022 depth,
4023 )?;
4024
4025 _prev_end_offset = cur_offset + envelope_size;
4026
4027 Ok(())
4028 }
4029 }
4030
4031 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4032 for ControlCodecStartResponse
4033 {
4034 #[inline(always)]
4035 fn new_empty() -> Self {
4036 Self::default()
4037 }
4038
4039 unsafe fn decode(
4040 &mut self,
4041 decoder: &mut fidl::encoding::Decoder<'_, D>,
4042 offset: usize,
4043 mut depth: fidl::encoding::Depth,
4044 ) -> fidl::Result<()> {
4045 decoder.debug_check_bounds::<Self>(offset);
4046 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4047 None => return Err(fidl::Error::NotNullable),
4048 Some(len) => len,
4049 };
4050 if len == 0 {
4052 return Ok(());
4053 };
4054 depth.increment()?;
4055 let envelope_size = 8;
4056 let bytes_len = len * envelope_size;
4057 let offset = decoder.out_of_line_offset(bytes_len)?;
4058 let mut _next_ordinal_to_read = 0;
4060 let mut next_offset = offset;
4061 let end_offset = offset + bytes_len;
4062 _next_ordinal_to_read += 1;
4063 if next_offset >= end_offset {
4064 return Ok(());
4065 }
4066
4067 while _next_ordinal_to_read < 1 {
4069 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4070 _next_ordinal_to_read += 1;
4071 next_offset += envelope_size;
4072 }
4073
4074 let next_out_of_line = decoder.next_out_of_line();
4075 let handles_before = decoder.remaining_handles();
4076 if let Some((inlined, num_bytes, num_handles)) =
4077 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4078 {
4079 let member_inline_size =
4080 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4081 if inlined != (member_inline_size <= 4) {
4082 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4083 }
4084 let inner_offset;
4085 let mut inner_depth = depth.clone();
4086 if inlined {
4087 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4088 inner_offset = next_offset;
4089 } else {
4090 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4091 inner_depth.increment()?;
4092 }
4093 let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4094 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4095 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4096 {
4097 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4098 }
4099 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4100 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4101 }
4102 }
4103
4104 next_offset += envelope_size;
4105
4106 while next_offset < end_offset {
4108 _next_ordinal_to_read += 1;
4109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4110 next_offset += envelope_size;
4111 }
4112
4113 Ok(())
4114 }
4115 }
4116
4117 impl ControlCodecStopResponse {
4118 #[inline(always)]
4119 fn max_ordinal_present(&self) -> u64 {
4120 if let Some(_) = self.stop_time {
4121 return 1;
4122 }
4123 0
4124 }
4125 }
4126
4127 impl fidl::encoding::ValueTypeMarker for ControlCodecStopResponse {
4128 type Borrowed<'a> = &'a Self;
4129 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4130 value
4131 }
4132 }
4133
4134 unsafe impl fidl::encoding::TypeMarker for ControlCodecStopResponse {
4135 type Owned = Self;
4136
4137 #[inline(always)]
4138 fn inline_align(_context: fidl::encoding::Context) -> usize {
4139 8
4140 }
4141
4142 #[inline(always)]
4143 fn inline_size(_context: fidl::encoding::Context) -> usize {
4144 16
4145 }
4146 }
4147
4148 unsafe impl<D: fidl::encoding::ResourceDialect>
4149 fidl::encoding::Encode<ControlCodecStopResponse, D> for &ControlCodecStopResponse
4150 {
4151 unsafe fn encode(
4152 self,
4153 encoder: &mut fidl::encoding::Encoder<'_, D>,
4154 offset: usize,
4155 mut depth: fidl::encoding::Depth,
4156 ) -> fidl::Result<()> {
4157 encoder.debug_check_bounds::<ControlCodecStopResponse>(offset);
4158 let max_ordinal: u64 = self.max_ordinal_present();
4160 encoder.write_num(max_ordinal, offset);
4161 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4162 if max_ordinal == 0 {
4164 return Ok(());
4165 }
4166 depth.increment()?;
4167 let envelope_size = 8;
4168 let bytes_len = max_ordinal as usize * envelope_size;
4169 #[allow(unused_variables)]
4170 let offset = encoder.out_of_line_offset(bytes_len);
4171 let mut _prev_end_offset: usize = 0;
4172 if 1 > max_ordinal {
4173 return Ok(());
4174 }
4175
4176 let cur_offset: usize = (1 - 1) * envelope_size;
4179
4180 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4182
4183 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4188 self.stop_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4189 encoder,
4190 offset + cur_offset,
4191 depth,
4192 )?;
4193
4194 _prev_end_offset = cur_offset + envelope_size;
4195
4196 Ok(())
4197 }
4198 }
4199
4200 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4201 for ControlCodecStopResponse
4202 {
4203 #[inline(always)]
4204 fn new_empty() -> Self {
4205 Self::default()
4206 }
4207
4208 unsafe fn decode(
4209 &mut self,
4210 decoder: &mut fidl::encoding::Decoder<'_, D>,
4211 offset: usize,
4212 mut depth: fidl::encoding::Depth,
4213 ) -> fidl::Result<()> {
4214 decoder.debug_check_bounds::<Self>(offset);
4215 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4216 None => return Err(fidl::Error::NotNullable),
4217 Some(len) => len,
4218 };
4219 if len == 0 {
4221 return Ok(());
4222 };
4223 depth.increment()?;
4224 let envelope_size = 8;
4225 let bytes_len = len * envelope_size;
4226 let offset = decoder.out_of_line_offset(bytes_len)?;
4227 let mut _next_ordinal_to_read = 0;
4229 let mut next_offset = offset;
4230 let end_offset = offset + bytes_len;
4231 _next_ordinal_to_read += 1;
4232 if next_offset >= end_offset {
4233 return Ok(());
4234 }
4235
4236 while _next_ordinal_to_read < 1 {
4238 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4239 _next_ordinal_to_read += 1;
4240 next_offset += envelope_size;
4241 }
4242
4243 let next_out_of_line = decoder.next_out_of_line();
4244 let handles_before = decoder.remaining_handles();
4245 if let Some((inlined, num_bytes, num_handles)) =
4246 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4247 {
4248 let member_inline_size =
4249 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4250 if inlined != (member_inline_size <= 4) {
4251 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4252 }
4253 let inner_offset;
4254 let mut inner_depth = depth.clone();
4255 if inlined {
4256 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4257 inner_offset = next_offset;
4258 } else {
4259 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4260 inner_depth.increment()?;
4261 }
4262 let val_ref = self.stop_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4263 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4264 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4265 {
4266 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4267 }
4268 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4269 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4270 }
4271 }
4272
4273 next_offset += envelope_size;
4274
4275 while next_offset < end_offset {
4277 _next_ordinal_to_read += 1;
4278 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4279 next_offset += envelope_size;
4280 }
4281
4282 Ok(())
4283 }
4284 }
4285
4286 impl ControlResetResponse {
4287 #[inline(always)]
4288 fn max_ordinal_present(&self) -> u64 {
4289 0
4290 }
4291 }
4292
4293 impl fidl::encoding::ValueTypeMarker for ControlResetResponse {
4294 type Borrowed<'a> = &'a Self;
4295 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4296 value
4297 }
4298 }
4299
4300 unsafe impl fidl::encoding::TypeMarker for ControlResetResponse {
4301 type Owned = Self;
4302
4303 #[inline(always)]
4304 fn inline_align(_context: fidl::encoding::Context) -> usize {
4305 8
4306 }
4307
4308 #[inline(always)]
4309 fn inline_size(_context: fidl::encoding::Context) -> usize {
4310 16
4311 }
4312 }
4313
4314 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlResetResponse, D>
4315 for &ControlResetResponse
4316 {
4317 unsafe fn encode(
4318 self,
4319 encoder: &mut fidl::encoding::Encoder<'_, D>,
4320 offset: usize,
4321 mut depth: fidl::encoding::Depth,
4322 ) -> fidl::Result<()> {
4323 encoder.debug_check_bounds::<ControlResetResponse>(offset);
4324 let max_ordinal: u64 = self.max_ordinal_present();
4326 encoder.write_num(max_ordinal, offset);
4327 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4328 if max_ordinal == 0 {
4330 return Ok(());
4331 }
4332 depth.increment()?;
4333 let envelope_size = 8;
4334 let bytes_len = max_ordinal as usize * envelope_size;
4335 #[allow(unused_variables)]
4336 let offset = encoder.out_of_line_offset(bytes_len);
4337 let mut _prev_end_offset: usize = 0;
4338
4339 Ok(())
4340 }
4341 }
4342
4343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetResponse {
4344 #[inline(always)]
4345 fn new_empty() -> Self {
4346 Self::default()
4347 }
4348
4349 unsafe fn decode(
4350 &mut self,
4351 decoder: &mut fidl::encoding::Decoder<'_, D>,
4352 offset: usize,
4353 mut depth: fidl::encoding::Depth,
4354 ) -> fidl::Result<()> {
4355 decoder.debug_check_bounds::<Self>(offset);
4356 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4357 None => return Err(fidl::Error::NotNullable),
4358 Some(len) => len,
4359 };
4360 if len == 0 {
4362 return Ok(());
4363 };
4364 depth.increment()?;
4365 let envelope_size = 8;
4366 let bytes_len = len * envelope_size;
4367 let offset = decoder.out_of_line_offset(bytes_len)?;
4368 let mut _next_ordinal_to_read = 0;
4370 let mut next_offset = offset;
4371 let end_offset = offset + bytes_len;
4372
4373 while next_offset < end_offset {
4375 _next_ordinal_to_read += 1;
4376 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4377 next_offset += envelope_size;
4378 }
4379
4380 Ok(())
4381 }
4382 }
4383
4384 impl ControlSetDaiFormatResponse {
4385 #[inline(always)]
4386 fn max_ordinal_present(&self) -> u64 {
4387 if let Some(_) = self.state {
4388 return 1;
4389 }
4390 0
4391 }
4392 }
4393
4394 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatResponse {
4395 type Borrowed<'a> = &'a Self;
4396 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4397 value
4398 }
4399 }
4400
4401 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatResponse {
4402 type Owned = Self;
4403
4404 #[inline(always)]
4405 fn inline_align(_context: fidl::encoding::Context) -> usize {
4406 8
4407 }
4408
4409 #[inline(always)]
4410 fn inline_size(_context: fidl::encoding::Context) -> usize {
4411 16
4412 }
4413 }
4414
4415 unsafe impl<D: fidl::encoding::ResourceDialect>
4416 fidl::encoding::Encode<ControlSetDaiFormatResponse, D> for &ControlSetDaiFormatResponse
4417 {
4418 unsafe fn encode(
4419 self,
4420 encoder: &mut fidl::encoding::Encoder<'_, D>,
4421 offset: usize,
4422 mut depth: fidl::encoding::Depth,
4423 ) -> fidl::Result<()> {
4424 encoder.debug_check_bounds::<ControlSetDaiFormatResponse>(offset);
4425 let max_ordinal: u64 = self.max_ordinal_present();
4427 encoder.write_num(max_ordinal, offset);
4428 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4429 if max_ordinal == 0 {
4431 return Ok(());
4432 }
4433 depth.increment()?;
4434 let envelope_size = 8;
4435 let bytes_len = max_ordinal as usize * envelope_size;
4436 #[allow(unused_variables)]
4437 let offset = encoder.out_of_line_offset(bytes_len);
4438 let mut _prev_end_offset: usize = 0;
4439 if 1 > max_ordinal {
4440 return Ok(());
4441 }
4442
4443 let cur_offset: usize = (1 - 1) * envelope_size;
4446
4447 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4449
4450 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D>(
4455 self.state.as_ref().map(<fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::ValueTypeMarker>::borrow),
4456 encoder, offset + cur_offset, depth
4457 )?;
4458
4459 _prev_end_offset = cur_offset + envelope_size;
4460
4461 Ok(())
4462 }
4463 }
4464
4465 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4466 for ControlSetDaiFormatResponse
4467 {
4468 #[inline(always)]
4469 fn new_empty() -> Self {
4470 Self::default()
4471 }
4472
4473 unsafe fn decode(
4474 &mut self,
4475 decoder: &mut fidl::encoding::Decoder<'_, D>,
4476 offset: usize,
4477 mut depth: fidl::encoding::Depth,
4478 ) -> fidl::Result<()> {
4479 decoder.debug_check_bounds::<Self>(offset);
4480 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4481 None => return Err(fidl::Error::NotNullable),
4482 Some(len) => len,
4483 };
4484 if len == 0 {
4486 return Ok(());
4487 };
4488 depth.increment()?;
4489 let envelope_size = 8;
4490 let bytes_len = len * envelope_size;
4491 let offset = decoder.out_of_line_offset(bytes_len)?;
4492 let mut _next_ordinal_to_read = 0;
4494 let mut next_offset = offset;
4495 let end_offset = offset + bytes_len;
4496 _next_ordinal_to_read += 1;
4497 if next_offset >= end_offset {
4498 return Ok(());
4499 }
4500
4501 while _next_ordinal_to_read < 1 {
4503 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4504 _next_ordinal_to_read += 1;
4505 next_offset += envelope_size;
4506 }
4507
4508 let next_out_of_line = decoder.next_out_of_line();
4509 let handles_before = decoder.remaining_handles();
4510 if let Some((inlined, num_bytes, num_handles)) =
4511 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4512 {
4513 let member_inline_size = <fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4514 if inlined != (member_inline_size <= 4) {
4515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4516 }
4517 let inner_offset;
4518 let mut inner_depth = depth.clone();
4519 if inlined {
4520 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4521 inner_offset = next_offset;
4522 } else {
4523 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4524 inner_depth.increment()?;
4525 }
4526 let val_ref = self.state.get_or_insert_with(|| {
4527 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D)
4528 });
4529 fidl::decode!(
4530 fidl_fuchsia_hardware_audio__common::CodecFormatInfo,
4531 D,
4532 val_ref,
4533 decoder,
4534 inner_offset,
4535 inner_depth
4536 )?;
4537 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4538 {
4539 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4540 }
4541 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4542 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4543 }
4544 }
4545
4546 next_offset += envelope_size;
4547
4548 while next_offset < end_offset {
4550 _next_ordinal_to_read += 1;
4551 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4552 next_offset += envelope_size;
4553 }
4554
4555 Ok(())
4556 }
4557 }
4558
4559 impl DelayInfo {
4560 #[inline(always)]
4561 fn max_ordinal_present(&self) -> u64 {
4562 if let Some(_) = self.external_delay {
4563 return 2;
4564 }
4565 if let Some(_) = self.internal_delay {
4566 return 1;
4567 }
4568 0
4569 }
4570 }
4571
4572 impl fidl::encoding::ValueTypeMarker for DelayInfo {
4573 type Borrowed<'a> = &'a Self;
4574 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4575 value
4576 }
4577 }
4578
4579 unsafe impl fidl::encoding::TypeMarker for DelayInfo {
4580 type Owned = Self;
4581
4582 #[inline(always)]
4583 fn inline_align(_context: fidl::encoding::Context) -> usize {
4584 8
4585 }
4586
4587 #[inline(always)]
4588 fn inline_size(_context: fidl::encoding::Context) -> usize {
4589 16
4590 }
4591 }
4592
4593 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DelayInfo, D>
4594 for &DelayInfo
4595 {
4596 unsafe fn encode(
4597 self,
4598 encoder: &mut fidl::encoding::Encoder<'_, D>,
4599 offset: usize,
4600 mut depth: fidl::encoding::Depth,
4601 ) -> fidl::Result<()> {
4602 encoder.debug_check_bounds::<DelayInfo>(offset);
4603 let max_ordinal: u64 = self.max_ordinal_present();
4605 encoder.write_num(max_ordinal, offset);
4606 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4607 if max_ordinal == 0 {
4609 return Ok(());
4610 }
4611 depth.increment()?;
4612 let envelope_size = 8;
4613 let bytes_len = max_ordinal as usize * envelope_size;
4614 #[allow(unused_variables)]
4615 let offset = encoder.out_of_line_offset(bytes_len);
4616 let mut _prev_end_offset: usize = 0;
4617 if 1 > max_ordinal {
4618 return Ok(());
4619 }
4620
4621 let cur_offset: usize = (1 - 1) * envelope_size;
4624
4625 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4627
4628 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4633 self.internal_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4634 encoder,
4635 offset + cur_offset,
4636 depth,
4637 )?;
4638
4639 _prev_end_offset = cur_offset + envelope_size;
4640 if 2 > max_ordinal {
4641 return Ok(());
4642 }
4643
4644 let cur_offset: usize = (2 - 1) * envelope_size;
4647
4648 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4650
4651 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4656 self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4657 encoder,
4658 offset + cur_offset,
4659 depth,
4660 )?;
4661
4662 _prev_end_offset = cur_offset + envelope_size;
4663
4664 Ok(())
4665 }
4666 }
4667
4668 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DelayInfo {
4669 #[inline(always)]
4670 fn new_empty() -> Self {
4671 Self::default()
4672 }
4673
4674 unsafe fn decode(
4675 &mut self,
4676 decoder: &mut fidl::encoding::Decoder<'_, D>,
4677 offset: usize,
4678 mut depth: fidl::encoding::Depth,
4679 ) -> fidl::Result<()> {
4680 decoder.debug_check_bounds::<Self>(offset);
4681 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4682 None => return Err(fidl::Error::NotNullable),
4683 Some(len) => len,
4684 };
4685 if len == 0 {
4687 return Ok(());
4688 };
4689 depth.increment()?;
4690 let envelope_size = 8;
4691 let bytes_len = len * envelope_size;
4692 let offset = decoder.out_of_line_offset(bytes_len)?;
4693 let mut _next_ordinal_to_read = 0;
4695 let mut next_offset = offset;
4696 let end_offset = offset + bytes_len;
4697 _next_ordinal_to_read += 1;
4698 if next_offset >= end_offset {
4699 return Ok(());
4700 }
4701
4702 while _next_ordinal_to_read < 1 {
4704 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4705 _next_ordinal_to_read += 1;
4706 next_offset += envelope_size;
4707 }
4708
4709 let next_out_of_line = decoder.next_out_of_line();
4710 let handles_before = decoder.remaining_handles();
4711 if let Some((inlined, num_bytes, num_handles)) =
4712 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4713 {
4714 let member_inline_size =
4715 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4716 if inlined != (member_inline_size <= 4) {
4717 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4718 }
4719 let inner_offset;
4720 let mut inner_depth = depth.clone();
4721 if inlined {
4722 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4723 inner_offset = next_offset;
4724 } else {
4725 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4726 inner_depth.increment()?;
4727 }
4728 let val_ref = self.internal_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4729 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4730 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4731 {
4732 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4733 }
4734 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4735 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4736 }
4737 }
4738
4739 next_offset += envelope_size;
4740 _next_ordinal_to_read += 1;
4741 if next_offset >= end_offset {
4742 return Ok(());
4743 }
4744
4745 while _next_ordinal_to_read < 2 {
4747 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4748 _next_ordinal_to_read += 1;
4749 next_offset += envelope_size;
4750 }
4751
4752 let next_out_of_line = decoder.next_out_of_line();
4753 let handles_before = decoder.remaining_handles();
4754 if let Some((inlined, num_bytes, num_handles)) =
4755 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4756 {
4757 let member_inline_size =
4758 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4759 if inlined != (member_inline_size <= 4) {
4760 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4761 }
4762 let inner_offset;
4763 let mut inner_depth = depth.clone();
4764 if inlined {
4765 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4766 inner_offset = next_offset;
4767 } else {
4768 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4769 inner_depth.increment()?;
4770 }
4771 let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4772 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4773 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4774 {
4775 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4776 }
4777 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4778 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4779 }
4780 }
4781
4782 next_offset += envelope_size;
4783
4784 while next_offset < end_offset {
4786 _next_ordinal_to_read += 1;
4787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4788 next_offset += envelope_size;
4789 }
4790
4791 Ok(())
4792 }
4793 }
4794
4795 impl ElementDaiFormatSet {
4796 #[inline(always)]
4797 fn max_ordinal_present(&self) -> u64 {
4798 if let Some(_) = self.format_sets {
4799 return 2;
4800 }
4801 if let Some(_) = self.element_id {
4802 return 1;
4803 }
4804 0
4805 }
4806 }
4807
4808 impl fidl::encoding::ValueTypeMarker for ElementDaiFormatSet {
4809 type Borrowed<'a> = &'a Self;
4810 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4811 value
4812 }
4813 }
4814
4815 unsafe impl fidl::encoding::TypeMarker for ElementDaiFormatSet {
4816 type Owned = Self;
4817
4818 #[inline(always)]
4819 fn inline_align(_context: fidl::encoding::Context) -> usize {
4820 8
4821 }
4822
4823 #[inline(always)]
4824 fn inline_size(_context: fidl::encoding::Context) -> usize {
4825 16
4826 }
4827 }
4828
4829 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementDaiFormatSet, D>
4830 for &ElementDaiFormatSet
4831 {
4832 unsafe fn encode(
4833 self,
4834 encoder: &mut fidl::encoding::Encoder<'_, D>,
4835 offset: usize,
4836 mut depth: fidl::encoding::Depth,
4837 ) -> fidl::Result<()> {
4838 encoder.debug_check_bounds::<ElementDaiFormatSet>(offset);
4839 let max_ordinal: u64 = self.max_ordinal_present();
4841 encoder.write_num(max_ordinal, offset);
4842 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4843 if max_ordinal == 0 {
4845 return Ok(());
4846 }
4847 depth.increment()?;
4848 let envelope_size = 8;
4849 let bytes_len = max_ordinal as usize * envelope_size;
4850 #[allow(unused_variables)]
4851 let offset = encoder.out_of_line_offset(bytes_len);
4852 let mut _prev_end_offset: usize = 0;
4853 if 1 > max_ordinal {
4854 return Ok(());
4855 }
4856
4857 let cur_offset: usize = (1 - 1) * envelope_size;
4860
4861 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4863
4864 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4869 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4870 encoder,
4871 offset + cur_offset,
4872 depth,
4873 )?;
4874
4875 _prev_end_offset = cur_offset + envelope_size;
4876 if 2 > max_ordinal {
4877 return Ok(());
4878 }
4879
4880 let cur_offset: usize = (2 - 1) * envelope_size;
4883
4884 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4886
4887 fidl::encoding::encode_in_envelope_optional::<
4892 fidl::encoding::Vector<
4893 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4894 64,
4895 >,
4896 D,
4897 >(
4898 self.format_sets.as_ref().map(
4899 <fidl::encoding::Vector<
4900 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4901 64,
4902 > as fidl::encoding::ValueTypeMarker>::borrow,
4903 ),
4904 encoder,
4905 offset + cur_offset,
4906 depth,
4907 )?;
4908
4909 _prev_end_offset = cur_offset + envelope_size;
4910
4911 Ok(())
4912 }
4913 }
4914
4915 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementDaiFormatSet {
4916 #[inline(always)]
4917 fn new_empty() -> Self {
4918 Self::default()
4919 }
4920
4921 unsafe fn decode(
4922 &mut self,
4923 decoder: &mut fidl::encoding::Decoder<'_, D>,
4924 offset: usize,
4925 mut depth: fidl::encoding::Depth,
4926 ) -> fidl::Result<()> {
4927 decoder.debug_check_bounds::<Self>(offset);
4928 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4929 None => return Err(fidl::Error::NotNullable),
4930 Some(len) => len,
4931 };
4932 if len == 0 {
4934 return Ok(());
4935 };
4936 depth.increment()?;
4937 let envelope_size = 8;
4938 let bytes_len = len * envelope_size;
4939 let offset = decoder.out_of_line_offset(bytes_len)?;
4940 let mut _next_ordinal_to_read = 0;
4942 let mut next_offset = offset;
4943 let end_offset = offset + bytes_len;
4944 _next_ordinal_to_read += 1;
4945 if next_offset >= end_offset {
4946 return Ok(());
4947 }
4948
4949 while _next_ordinal_to_read < 1 {
4951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4952 _next_ordinal_to_read += 1;
4953 next_offset += envelope_size;
4954 }
4955
4956 let next_out_of_line = decoder.next_out_of_line();
4957 let handles_before = decoder.remaining_handles();
4958 if let Some((inlined, num_bytes, num_handles)) =
4959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4960 {
4961 let member_inline_size =
4962 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4963 if inlined != (member_inline_size <= 4) {
4964 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4965 }
4966 let inner_offset;
4967 let mut inner_depth = depth.clone();
4968 if inlined {
4969 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4970 inner_offset = next_offset;
4971 } else {
4972 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4973 inner_depth.increment()?;
4974 }
4975 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4976 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4978 {
4979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4980 }
4981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4983 }
4984 }
4985
4986 next_offset += envelope_size;
4987 _next_ordinal_to_read += 1;
4988 if next_offset >= end_offset {
4989 return Ok(());
4990 }
4991
4992 while _next_ordinal_to_read < 2 {
4994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4995 _next_ordinal_to_read += 1;
4996 next_offset += envelope_size;
4997 }
4998
4999 let next_out_of_line = decoder.next_out_of_line();
5000 let handles_before = decoder.remaining_handles();
5001 if let Some((inlined, num_bytes, num_handles)) =
5002 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5003 {
5004 let member_inline_size = <fidl::encoding::Vector<
5005 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
5006 64,
5007 > as fidl::encoding::TypeMarker>::inline_size(
5008 decoder.context
5009 );
5010 if inlined != (member_inline_size <= 4) {
5011 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5012 }
5013 let inner_offset;
5014 let mut inner_depth = depth.clone();
5015 if inlined {
5016 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5017 inner_offset = next_offset;
5018 } else {
5019 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5020 inner_depth.increment()?;
5021 }
5022 let val_ref =
5023 self.format_sets.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D));
5024 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5025 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5026 {
5027 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5028 }
5029 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5030 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5031 }
5032 }
5033
5034 next_offset += envelope_size;
5035
5036 while next_offset < end_offset {
5038 _next_ordinal_to_read += 1;
5039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5040 next_offset += envelope_size;
5041 }
5042
5043 Ok(())
5044 }
5045 }
5046
5047 impl ElementRingBufferFormatSet {
5048 #[inline(always)]
5049 fn max_ordinal_present(&self) -> u64 {
5050 if let Some(_) = self.format_sets {
5051 return 2;
5052 }
5053 if let Some(_) = self.element_id {
5054 return 1;
5055 }
5056 0
5057 }
5058 }
5059
5060 impl fidl::encoding::ValueTypeMarker for ElementRingBufferFormatSet {
5061 type Borrowed<'a> = &'a Self;
5062 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5063 value
5064 }
5065 }
5066
5067 unsafe impl fidl::encoding::TypeMarker for ElementRingBufferFormatSet {
5068 type Owned = Self;
5069
5070 #[inline(always)]
5071 fn inline_align(_context: fidl::encoding::Context) -> usize {
5072 8
5073 }
5074
5075 #[inline(always)]
5076 fn inline_size(_context: fidl::encoding::Context) -> usize {
5077 16
5078 }
5079 }
5080
5081 unsafe impl<D: fidl::encoding::ResourceDialect>
5082 fidl::encoding::Encode<ElementRingBufferFormatSet, D> for &ElementRingBufferFormatSet
5083 {
5084 unsafe fn encode(
5085 self,
5086 encoder: &mut fidl::encoding::Encoder<'_, D>,
5087 offset: usize,
5088 mut depth: fidl::encoding::Depth,
5089 ) -> fidl::Result<()> {
5090 encoder.debug_check_bounds::<ElementRingBufferFormatSet>(offset);
5091 let max_ordinal: u64 = self.max_ordinal_present();
5093 encoder.write_num(max_ordinal, offset);
5094 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5095 if max_ordinal == 0 {
5097 return Ok(());
5098 }
5099 depth.increment()?;
5100 let envelope_size = 8;
5101 let bytes_len = max_ordinal as usize * envelope_size;
5102 #[allow(unused_variables)]
5103 let offset = encoder.out_of_line_offset(bytes_len);
5104 let mut _prev_end_offset: usize = 0;
5105 if 1 > max_ordinal {
5106 return Ok(());
5107 }
5108
5109 let cur_offset: usize = (1 - 1) * envelope_size;
5112
5113 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5115
5116 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5121 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5122 encoder,
5123 offset + cur_offset,
5124 depth,
5125 )?;
5126
5127 _prev_end_offset = cur_offset + envelope_size;
5128 if 2 > max_ordinal {
5129 return Ok(());
5130 }
5131
5132 let cur_offset: usize = (2 - 1) * envelope_size;
5135
5136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5138
5139 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PcmFormatSet, 64>, D>(
5144 self.format_sets.as_ref().map(<fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5145 encoder, offset + cur_offset, depth
5146 )?;
5147
5148 _prev_end_offset = cur_offset + envelope_size;
5149
5150 Ok(())
5151 }
5152 }
5153
5154 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5155 for ElementRingBufferFormatSet
5156 {
5157 #[inline(always)]
5158 fn new_empty() -> Self {
5159 Self::default()
5160 }
5161
5162 unsafe fn decode(
5163 &mut self,
5164 decoder: &mut fidl::encoding::Decoder<'_, D>,
5165 offset: usize,
5166 mut depth: fidl::encoding::Depth,
5167 ) -> fidl::Result<()> {
5168 decoder.debug_check_bounds::<Self>(offset);
5169 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5170 None => return Err(fidl::Error::NotNullable),
5171 Some(len) => len,
5172 };
5173 if len == 0 {
5175 return Ok(());
5176 };
5177 depth.increment()?;
5178 let envelope_size = 8;
5179 let bytes_len = len * envelope_size;
5180 let offset = decoder.out_of_line_offset(bytes_len)?;
5181 let mut _next_ordinal_to_read = 0;
5183 let mut next_offset = offset;
5184 let end_offset = offset + bytes_len;
5185 _next_ordinal_to_read += 1;
5186 if next_offset >= end_offset {
5187 return Ok(());
5188 }
5189
5190 while _next_ordinal_to_read < 1 {
5192 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5193 _next_ordinal_to_read += 1;
5194 next_offset += envelope_size;
5195 }
5196
5197 let next_out_of_line = decoder.next_out_of_line();
5198 let handles_before = decoder.remaining_handles();
5199 if let Some((inlined, num_bytes, num_handles)) =
5200 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5201 {
5202 let member_inline_size =
5203 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5204 if inlined != (member_inline_size <= 4) {
5205 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5206 }
5207 let inner_offset;
5208 let mut inner_depth = depth.clone();
5209 if inlined {
5210 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5211 inner_offset = next_offset;
5212 } else {
5213 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5214 inner_depth.increment()?;
5215 }
5216 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5217 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5218 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5219 {
5220 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5221 }
5222 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5223 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5224 }
5225 }
5226
5227 next_offset += envelope_size;
5228 _next_ordinal_to_read += 1;
5229 if next_offset >= end_offset {
5230 return Ok(());
5231 }
5232
5233 while _next_ordinal_to_read < 2 {
5235 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5236 _next_ordinal_to_read += 1;
5237 next_offset += envelope_size;
5238 }
5239
5240 let next_out_of_line = decoder.next_out_of_line();
5241 let handles_before = decoder.remaining_handles();
5242 if let Some((inlined, num_bytes, num_handles)) =
5243 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5244 {
5245 let member_inline_size = <fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5246 if inlined != (member_inline_size <= 4) {
5247 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5248 }
5249 let inner_offset;
5250 let mut inner_depth = depth.clone();
5251 if inlined {
5252 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5253 inner_offset = next_offset;
5254 } else {
5255 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5256 inner_depth.increment()?;
5257 }
5258 let val_ref = self.format_sets.get_or_insert_with(
5259 || fidl::new_empty!(fidl::encoding::Vector<PcmFormatSet, 64>, D),
5260 );
5261 fidl::decode!(fidl::encoding::Vector<PcmFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5262 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5263 {
5264 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5265 }
5266 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5267 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5268 }
5269 }
5270
5271 next_offset += envelope_size;
5272
5273 while next_offset < end_offset {
5275 _next_ordinal_to_read += 1;
5276 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5277 next_offset += envelope_size;
5278 }
5279
5280 Ok(())
5281 }
5282 }
5283
5284 impl Info {
5285 #[inline(always)]
5286 fn max_ordinal_present(&self) -> u64 {
5287 if let Some(_) = self.signal_processing_topologies {
5288 return 13;
5289 }
5290 if let Some(_) = self.signal_processing_elements {
5291 return 12;
5292 }
5293 if let Some(_) = self.clock_domain {
5294 return 11;
5295 }
5296 if let Some(_) = self.plug_detect_caps {
5297 return 10;
5298 }
5299 if let Some(_) = self.dai_format_sets {
5300 return 9;
5301 }
5302 if let Some(_) = self.ring_buffer_format_sets {
5303 return 8;
5304 }
5305 if let Some(_) = self.is_input {
5306 return 7;
5307 }
5308 if let Some(_) = self.unique_instance_id {
5309 return 6;
5310 }
5311 if let Some(_) = self.product {
5312 return 5;
5313 }
5314 if let Some(_) = self.manufacturer {
5315 return 4;
5316 }
5317 if let Some(_) = self.device_name {
5318 return 3;
5319 }
5320 if let Some(_) = self.device_type {
5321 return 2;
5322 }
5323 if let Some(_) = self.token_id {
5324 return 1;
5325 }
5326 0
5327 }
5328 }
5329
5330 impl fidl::encoding::ValueTypeMarker for Info {
5331 type Borrowed<'a> = &'a Self;
5332 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5333 value
5334 }
5335 }
5336
5337 unsafe impl fidl::encoding::TypeMarker for Info {
5338 type Owned = Self;
5339
5340 #[inline(always)]
5341 fn inline_align(_context: fidl::encoding::Context) -> usize {
5342 8
5343 }
5344
5345 #[inline(always)]
5346 fn inline_size(_context: fidl::encoding::Context) -> usize {
5347 16
5348 }
5349 }
5350
5351 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Info, D> for &Info {
5352 unsafe fn encode(
5353 self,
5354 encoder: &mut fidl::encoding::Encoder<'_, D>,
5355 offset: usize,
5356 mut depth: fidl::encoding::Depth,
5357 ) -> fidl::Result<()> {
5358 encoder.debug_check_bounds::<Info>(offset);
5359 let max_ordinal: u64 = self.max_ordinal_present();
5361 encoder.write_num(max_ordinal, offset);
5362 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5363 if max_ordinal == 0 {
5365 return Ok(());
5366 }
5367 depth.increment()?;
5368 let envelope_size = 8;
5369 let bytes_len = max_ordinal as usize * envelope_size;
5370 #[allow(unused_variables)]
5371 let offset = encoder.out_of_line_offset(bytes_len);
5372 let mut _prev_end_offset: usize = 0;
5373 if 1 > max_ordinal {
5374 return Ok(());
5375 }
5376
5377 let cur_offset: usize = (1 - 1) * envelope_size;
5380
5381 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5383
5384 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5389 self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5390 encoder,
5391 offset + cur_offset,
5392 depth,
5393 )?;
5394
5395 _prev_end_offset = cur_offset + envelope_size;
5396 if 2 > max_ordinal {
5397 return Ok(());
5398 }
5399
5400 let cur_offset: usize = (2 - 1) * envelope_size;
5403
5404 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5406
5407 fidl::encoding::encode_in_envelope_optional::<DeviceType, D>(
5412 self.device_type
5413 .as_ref()
5414 .map(<DeviceType as fidl::encoding::ValueTypeMarker>::borrow),
5415 encoder,
5416 offset + cur_offset,
5417 depth,
5418 )?;
5419
5420 _prev_end_offset = cur_offset + envelope_size;
5421 if 3 > max_ordinal {
5422 return Ok(());
5423 }
5424
5425 let cur_offset: usize = (3 - 1) * envelope_size;
5428
5429 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5431
5432 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5437 self.device_name.as_ref().map(
5438 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5439 ),
5440 encoder,
5441 offset + cur_offset,
5442 depth,
5443 )?;
5444
5445 _prev_end_offset = cur_offset + envelope_size;
5446 if 4 > max_ordinal {
5447 return Ok(());
5448 }
5449
5450 let cur_offset: usize = (4 - 1) * envelope_size;
5453
5454 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5456
5457 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5462 self.manufacturer.as_ref().map(
5463 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5464 ),
5465 encoder,
5466 offset + cur_offset,
5467 depth,
5468 )?;
5469
5470 _prev_end_offset = cur_offset + envelope_size;
5471 if 5 > max_ordinal {
5472 return Ok(());
5473 }
5474
5475 let cur_offset: usize = (5 - 1) * envelope_size;
5478
5479 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5481
5482 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5487 self.product.as_ref().map(
5488 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5489 ),
5490 encoder,
5491 offset + cur_offset,
5492 depth,
5493 )?;
5494
5495 _prev_end_offset = cur_offset + envelope_size;
5496 if 6 > max_ordinal {
5497 return Ok(());
5498 }
5499
5500 let cur_offset: usize = (6 - 1) * envelope_size;
5503
5504 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5506
5507 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
5512 self.unique_instance_id.as_ref().map(
5513 <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
5514 ),
5515 encoder,
5516 offset + cur_offset,
5517 depth,
5518 )?;
5519
5520 _prev_end_offset = cur_offset + envelope_size;
5521 if 7 > max_ordinal {
5522 return Ok(());
5523 }
5524
5525 let cur_offset: usize = (7 - 1) * envelope_size;
5528
5529 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5531
5532 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5537 self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5538 encoder,
5539 offset + cur_offset,
5540 depth,
5541 )?;
5542
5543 _prev_end_offset = cur_offset + envelope_size;
5544 if 8 > max_ordinal {
5545 return Ok(());
5546 }
5547
5548 let cur_offset: usize = (8 - 1) * envelope_size;
5551
5552 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5554
5555 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D>(
5560 self.ring_buffer_format_sets.as_ref().map(<fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5561 encoder, offset + cur_offset, depth
5562 )?;
5563
5564 _prev_end_offset = cur_offset + envelope_size;
5565 if 9 > max_ordinal {
5566 return Ok(());
5567 }
5568
5569 let cur_offset: usize = (9 - 1) * envelope_size;
5572
5573 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5575
5576 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementDaiFormatSet, 64>, D>(
5581 self.dai_format_sets.as_ref().map(<fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5582 encoder, offset + cur_offset, depth
5583 )?;
5584
5585 _prev_end_offset = cur_offset + envelope_size;
5586 if 10 > max_ordinal {
5587 return Ok(());
5588 }
5589
5590 let cur_offset: usize = (10 - 1) * envelope_size;
5593
5594 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5596
5597 fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
5602 self.plug_detect_caps
5603 .as_ref()
5604 .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
5605 encoder,
5606 offset + cur_offset,
5607 depth,
5608 )?;
5609
5610 _prev_end_offset = cur_offset + envelope_size;
5611 if 11 > max_ordinal {
5612 return Ok(());
5613 }
5614
5615 let cur_offset: usize = (11 - 1) * envelope_size;
5618
5619 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5621
5622 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5627 self.clock_domain.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5628 encoder,
5629 offset + cur_offset,
5630 depth,
5631 )?;
5632
5633 _prev_end_offset = cur_offset + envelope_size;
5634 if 12 > max_ordinal {
5635 return Ok(());
5636 }
5637
5638 let cur_offset: usize = (12 - 1) * envelope_size;
5641
5642 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5644
5645 fidl::encoding::encode_in_envelope_optional::<
5650 fidl::encoding::Vector<
5651 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5652 64,
5653 >,
5654 D,
5655 >(
5656 self.signal_processing_elements.as_ref().map(
5657 <fidl::encoding::Vector<
5658 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5659 64,
5660 > as fidl::encoding::ValueTypeMarker>::borrow,
5661 ),
5662 encoder,
5663 offset + cur_offset,
5664 depth,
5665 )?;
5666
5667 _prev_end_offset = cur_offset + envelope_size;
5668 if 13 > max_ordinal {
5669 return Ok(());
5670 }
5671
5672 let cur_offset: usize = (13 - 1) * envelope_size;
5675
5676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5678
5679 fidl::encoding::encode_in_envelope_optional::<
5684 fidl::encoding::Vector<
5685 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5686 64,
5687 >,
5688 D,
5689 >(
5690 self.signal_processing_topologies.as_ref().map(
5691 <fidl::encoding::Vector<
5692 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5693 64,
5694 > as fidl::encoding::ValueTypeMarker>::borrow,
5695 ),
5696 encoder,
5697 offset + cur_offset,
5698 depth,
5699 )?;
5700
5701 _prev_end_offset = cur_offset + envelope_size;
5702
5703 Ok(())
5704 }
5705 }
5706
5707 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Info {
5708 #[inline(always)]
5709 fn new_empty() -> Self {
5710 Self::default()
5711 }
5712
5713 unsafe fn decode(
5714 &mut self,
5715 decoder: &mut fidl::encoding::Decoder<'_, D>,
5716 offset: usize,
5717 mut depth: fidl::encoding::Depth,
5718 ) -> fidl::Result<()> {
5719 decoder.debug_check_bounds::<Self>(offset);
5720 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5721 None => return Err(fidl::Error::NotNullable),
5722 Some(len) => len,
5723 };
5724 if len == 0 {
5726 return Ok(());
5727 };
5728 depth.increment()?;
5729 let envelope_size = 8;
5730 let bytes_len = len * envelope_size;
5731 let offset = decoder.out_of_line_offset(bytes_len)?;
5732 let mut _next_ordinal_to_read = 0;
5734 let mut next_offset = offset;
5735 let end_offset = offset + bytes_len;
5736 _next_ordinal_to_read += 1;
5737 if next_offset >= end_offset {
5738 return Ok(());
5739 }
5740
5741 while _next_ordinal_to_read < 1 {
5743 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5744 _next_ordinal_to_read += 1;
5745 next_offset += envelope_size;
5746 }
5747
5748 let next_out_of_line = decoder.next_out_of_line();
5749 let handles_before = decoder.remaining_handles();
5750 if let Some((inlined, num_bytes, num_handles)) =
5751 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5752 {
5753 let member_inline_size =
5754 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5755 if inlined != (member_inline_size <= 4) {
5756 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5757 }
5758 let inner_offset;
5759 let mut inner_depth = depth.clone();
5760 if inlined {
5761 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5762 inner_offset = next_offset;
5763 } else {
5764 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5765 inner_depth.increment()?;
5766 }
5767 let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5768 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5769 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5770 {
5771 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5772 }
5773 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5774 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5775 }
5776 }
5777
5778 next_offset += envelope_size;
5779 _next_ordinal_to_read += 1;
5780 if next_offset >= end_offset {
5781 return Ok(());
5782 }
5783
5784 while _next_ordinal_to_read < 2 {
5786 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5787 _next_ordinal_to_read += 1;
5788 next_offset += envelope_size;
5789 }
5790
5791 let next_out_of_line = decoder.next_out_of_line();
5792 let handles_before = decoder.remaining_handles();
5793 if let Some((inlined, num_bytes, num_handles)) =
5794 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5795 {
5796 let member_inline_size =
5797 <DeviceType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5798 if inlined != (member_inline_size <= 4) {
5799 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5800 }
5801 let inner_offset;
5802 let mut inner_depth = depth.clone();
5803 if inlined {
5804 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5805 inner_offset = next_offset;
5806 } else {
5807 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5808 inner_depth.increment()?;
5809 }
5810 let val_ref =
5811 self.device_type.get_or_insert_with(|| fidl::new_empty!(DeviceType, D));
5812 fidl::decode!(DeviceType, D, val_ref, decoder, inner_offset, inner_depth)?;
5813 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5814 {
5815 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5816 }
5817 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5818 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5819 }
5820 }
5821
5822 next_offset += envelope_size;
5823 _next_ordinal_to_read += 1;
5824 if next_offset >= end_offset {
5825 return Ok(());
5826 }
5827
5828 while _next_ordinal_to_read < 3 {
5830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5831 _next_ordinal_to_read += 1;
5832 next_offset += envelope_size;
5833 }
5834
5835 let next_out_of_line = decoder.next_out_of_line();
5836 let handles_before = decoder.remaining_handles();
5837 if let Some((inlined, num_bytes, num_handles)) =
5838 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5839 {
5840 let member_inline_size =
5841 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5842 decoder.context,
5843 );
5844 if inlined != (member_inline_size <= 4) {
5845 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5846 }
5847 let inner_offset;
5848 let mut inner_depth = depth.clone();
5849 if inlined {
5850 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5851 inner_offset = next_offset;
5852 } else {
5853 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5854 inner_depth.increment()?;
5855 }
5856 let val_ref = self
5857 .device_name
5858 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5859 fidl::decode!(
5860 fidl::encoding::BoundedString<256>,
5861 D,
5862 val_ref,
5863 decoder,
5864 inner_offset,
5865 inner_depth
5866 )?;
5867 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5868 {
5869 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5870 }
5871 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5872 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5873 }
5874 }
5875
5876 next_offset += envelope_size;
5877 _next_ordinal_to_read += 1;
5878 if next_offset >= end_offset {
5879 return Ok(());
5880 }
5881
5882 while _next_ordinal_to_read < 4 {
5884 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5885 _next_ordinal_to_read += 1;
5886 next_offset += envelope_size;
5887 }
5888
5889 let next_out_of_line = decoder.next_out_of_line();
5890 let handles_before = decoder.remaining_handles();
5891 if let Some((inlined, num_bytes, num_handles)) =
5892 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5893 {
5894 let member_inline_size =
5895 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5896 decoder.context,
5897 );
5898 if inlined != (member_inline_size <= 4) {
5899 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5900 }
5901 let inner_offset;
5902 let mut inner_depth = depth.clone();
5903 if inlined {
5904 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5905 inner_offset = next_offset;
5906 } else {
5907 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5908 inner_depth.increment()?;
5909 }
5910 let val_ref = self
5911 .manufacturer
5912 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5913 fidl::decode!(
5914 fidl::encoding::BoundedString<256>,
5915 D,
5916 val_ref,
5917 decoder,
5918 inner_offset,
5919 inner_depth
5920 )?;
5921 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5922 {
5923 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5924 }
5925 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5926 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5927 }
5928 }
5929
5930 next_offset += envelope_size;
5931 _next_ordinal_to_read += 1;
5932 if next_offset >= end_offset {
5933 return Ok(());
5934 }
5935
5936 while _next_ordinal_to_read < 5 {
5938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5939 _next_ordinal_to_read += 1;
5940 next_offset += envelope_size;
5941 }
5942
5943 let next_out_of_line = decoder.next_out_of_line();
5944 let handles_before = decoder.remaining_handles();
5945 if let Some((inlined, num_bytes, num_handles)) =
5946 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5947 {
5948 let member_inline_size =
5949 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5950 decoder.context,
5951 );
5952 if inlined != (member_inline_size <= 4) {
5953 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5954 }
5955 let inner_offset;
5956 let mut inner_depth = depth.clone();
5957 if inlined {
5958 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5959 inner_offset = next_offset;
5960 } else {
5961 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5962 inner_depth.increment()?;
5963 }
5964 let val_ref = self
5965 .product
5966 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5967 fidl::decode!(
5968 fidl::encoding::BoundedString<256>,
5969 D,
5970 val_ref,
5971 decoder,
5972 inner_offset,
5973 inner_depth
5974 )?;
5975 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5976 {
5977 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5978 }
5979 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5980 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5981 }
5982 }
5983
5984 next_offset += envelope_size;
5985 _next_ordinal_to_read += 1;
5986 if next_offset >= end_offset {
5987 return Ok(());
5988 }
5989
5990 while _next_ordinal_to_read < 6 {
5992 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5993 _next_ordinal_to_read += 1;
5994 next_offset += envelope_size;
5995 }
5996
5997 let next_out_of_line = decoder.next_out_of_line();
5998 let handles_before = decoder.remaining_handles();
5999 if let Some((inlined, num_bytes, num_handles)) =
6000 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6001 {
6002 let member_inline_size =
6003 <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
6004 decoder.context,
6005 );
6006 if inlined != (member_inline_size <= 4) {
6007 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6008 }
6009 let inner_offset;
6010 let mut inner_depth = depth.clone();
6011 if inlined {
6012 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6013 inner_offset = next_offset;
6014 } else {
6015 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6016 inner_depth.increment()?;
6017 }
6018 let val_ref = self
6019 .unique_instance_id
6020 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
6021 fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
6022 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6023 {
6024 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6025 }
6026 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6027 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6028 }
6029 }
6030
6031 next_offset += envelope_size;
6032 _next_ordinal_to_read += 1;
6033 if next_offset >= end_offset {
6034 return Ok(());
6035 }
6036
6037 while _next_ordinal_to_read < 7 {
6039 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6040 _next_ordinal_to_read += 1;
6041 next_offset += envelope_size;
6042 }
6043
6044 let next_out_of_line = decoder.next_out_of_line();
6045 let handles_before = decoder.remaining_handles();
6046 if let Some((inlined, num_bytes, num_handles)) =
6047 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6048 {
6049 let member_inline_size =
6050 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6051 if inlined != (member_inline_size <= 4) {
6052 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6053 }
6054 let inner_offset;
6055 let mut inner_depth = depth.clone();
6056 if inlined {
6057 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6058 inner_offset = next_offset;
6059 } else {
6060 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6061 inner_depth.increment()?;
6062 }
6063 let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
6064 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6065 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6066 {
6067 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6068 }
6069 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6070 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6071 }
6072 }
6073
6074 next_offset += envelope_size;
6075 _next_ordinal_to_read += 1;
6076 if next_offset >= end_offset {
6077 return Ok(());
6078 }
6079
6080 while _next_ordinal_to_read < 8 {
6082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6083 _next_ordinal_to_read += 1;
6084 next_offset += envelope_size;
6085 }
6086
6087 let next_out_of_line = decoder.next_out_of_line();
6088 let handles_before = decoder.remaining_handles();
6089 if let Some((inlined, num_bytes, num_handles)) =
6090 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6091 {
6092 let member_inline_size = <fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6093 if inlined != (member_inline_size <= 4) {
6094 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6095 }
6096 let inner_offset;
6097 let mut inner_depth = depth.clone();
6098 if inlined {
6099 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6100 inner_offset = next_offset;
6101 } else {
6102 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6103 inner_depth.increment()?;
6104 }
6105 let val_ref = self.ring_buffer_format_sets.get_or_insert_with(
6106 || fidl::new_empty!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D),
6107 );
6108 fidl::decode!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6109 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6110 {
6111 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6112 }
6113 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6114 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6115 }
6116 }
6117
6118 next_offset += envelope_size;
6119 _next_ordinal_to_read += 1;
6120 if next_offset >= end_offset {
6121 return Ok(());
6122 }
6123
6124 while _next_ordinal_to_read < 9 {
6126 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6127 _next_ordinal_to_read += 1;
6128 next_offset += envelope_size;
6129 }
6130
6131 let next_out_of_line = decoder.next_out_of_line();
6132 let handles_before = decoder.remaining_handles();
6133 if let Some((inlined, num_bytes, num_handles)) =
6134 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6135 {
6136 let member_inline_size = <fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6137 if inlined != (member_inline_size <= 4) {
6138 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6139 }
6140 let inner_offset;
6141 let mut inner_depth = depth.clone();
6142 if inlined {
6143 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6144 inner_offset = next_offset;
6145 } else {
6146 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6147 inner_depth.increment()?;
6148 }
6149 let val_ref = self.dai_format_sets.get_or_insert_with(
6150 || fidl::new_empty!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D),
6151 );
6152 fidl::decode!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6153 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6154 {
6155 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6156 }
6157 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6158 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6159 }
6160 }
6161
6162 next_offset += envelope_size;
6163 _next_ordinal_to_read += 1;
6164 if next_offset >= end_offset {
6165 return Ok(());
6166 }
6167
6168 while _next_ordinal_to_read < 10 {
6170 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6171 _next_ordinal_to_read += 1;
6172 next_offset += envelope_size;
6173 }
6174
6175 let next_out_of_line = decoder.next_out_of_line();
6176 let handles_before = decoder.remaining_handles();
6177 if let Some((inlined, num_bytes, num_handles)) =
6178 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6179 {
6180 let member_inline_size =
6181 <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6182 decoder.context,
6183 );
6184 if inlined != (member_inline_size <= 4) {
6185 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6186 }
6187 let inner_offset;
6188 let mut inner_depth = depth.clone();
6189 if inlined {
6190 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6191 inner_offset = next_offset;
6192 } else {
6193 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6194 inner_depth.increment()?;
6195 }
6196 let val_ref = self
6197 .plug_detect_caps
6198 .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6199 fidl::decode!(
6200 PlugDetectCapabilities,
6201 D,
6202 val_ref,
6203 decoder,
6204 inner_offset,
6205 inner_depth
6206 )?;
6207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6208 {
6209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6210 }
6211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6213 }
6214 }
6215
6216 next_offset += envelope_size;
6217 _next_ordinal_to_read += 1;
6218 if next_offset >= end_offset {
6219 return Ok(());
6220 }
6221
6222 while _next_ordinal_to_read < 11 {
6224 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6225 _next_ordinal_to_read += 1;
6226 next_offset += envelope_size;
6227 }
6228
6229 let next_out_of_line = decoder.next_out_of_line();
6230 let handles_before = decoder.remaining_handles();
6231 if let Some((inlined, num_bytes, num_handles)) =
6232 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6233 {
6234 let member_inline_size =
6235 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6236 if inlined != (member_inline_size <= 4) {
6237 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6238 }
6239 let inner_offset;
6240 let mut inner_depth = depth.clone();
6241 if inlined {
6242 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6243 inner_offset = next_offset;
6244 } else {
6245 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6246 inner_depth.increment()?;
6247 }
6248 let val_ref = self.clock_domain.get_or_insert_with(|| fidl::new_empty!(u32, D));
6249 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6250 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6251 {
6252 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6253 }
6254 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6255 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6256 }
6257 }
6258
6259 next_offset += envelope_size;
6260 _next_ordinal_to_read += 1;
6261 if next_offset >= end_offset {
6262 return Ok(());
6263 }
6264
6265 while _next_ordinal_to_read < 12 {
6267 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6268 _next_ordinal_to_read += 1;
6269 next_offset += envelope_size;
6270 }
6271
6272 let next_out_of_line = decoder.next_out_of_line();
6273 let handles_before = decoder.remaining_handles();
6274 if let Some((inlined, num_bytes, num_handles)) =
6275 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6276 {
6277 let member_inline_size = <fidl::encoding::Vector<
6278 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
6279 64,
6280 > as fidl::encoding::TypeMarker>::inline_size(
6281 decoder.context
6282 );
6283 if inlined != (member_inline_size <= 4) {
6284 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6285 }
6286 let inner_offset;
6287 let mut inner_depth = depth.clone();
6288 if inlined {
6289 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6290 inner_offset = next_offset;
6291 } else {
6292 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6293 inner_depth.increment()?;
6294 }
6295 let val_ref =
6296 self.signal_processing_elements.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D));
6297 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6299 {
6300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6301 }
6302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6304 }
6305 }
6306
6307 next_offset += envelope_size;
6308 _next_ordinal_to_read += 1;
6309 if next_offset >= end_offset {
6310 return Ok(());
6311 }
6312
6313 while _next_ordinal_to_read < 13 {
6315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6316 _next_ordinal_to_read += 1;
6317 next_offset += envelope_size;
6318 }
6319
6320 let next_out_of_line = decoder.next_out_of_line();
6321 let handles_before = decoder.remaining_handles();
6322 if let Some((inlined, num_bytes, num_handles)) =
6323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6324 {
6325 let member_inline_size = <fidl::encoding::Vector<
6326 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
6327 64,
6328 > as fidl::encoding::TypeMarker>::inline_size(
6329 decoder.context
6330 );
6331 if inlined != (member_inline_size <= 4) {
6332 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6333 }
6334 let inner_offset;
6335 let mut inner_depth = depth.clone();
6336 if inlined {
6337 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6338 inner_offset = next_offset;
6339 } else {
6340 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6341 inner_depth.increment()?;
6342 }
6343 let val_ref =
6344 self.signal_processing_topologies.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D));
6345 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6346 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6347 {
6348 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6349 }
6350 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6351 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6352 }
6353 }
6354
6355 next_offset += envelope_size;
6356
6357 while next_offset < end_offset {
6359 _next_ordinal_to_read += 1;
6360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6361 next_offset += envelope_size;
6362 }
6363
6364 Ok(())
6365 }
6366 }
6367
6368 impl ObserverWatchPlugStateResponse {
6369 #[inline(always)]
6370 fn max_ordinal_present(&self) -> u64 {
6371 if let Some(_) = self.plug_time {
6372 return 2;
6373 }
6374 if let Some(_) = self.state {
6375 return 1;
6376 }
6377 0
6378 }
6379 }
6380
6381 impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateResponse {
6382 type Borrowed<'a> = &'a Self;
6383 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6384 value
6385 }
6386 }
6387
6388 unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateResponse {
6389 type Owned = Self;
6390
6391 #[inline(always)]
6392 fn inline_align(_context: fidl::encoding::Context) -> usize {
6393 8
6394 }
6395
6396 #[inline(always)]
6397 fn inline_size(_context: fidl::encoding::Context) -> usize {
6398 16
6399 }
6400 }
6401
6402 unsafe impl<D: fidl::encoding::ResourceDialect>
6403 fidl::encoding::Encode<ObserverWatchPlugStateResponse, D>
6404 for &ObserverWatchPlugStateResponse
6405 {
6406 unsafe fn encode(
6407 self,
6408 encoder: &mut fidl::encoding::Encoder<'_, D>,
6409 offset: usize,
6410 mut depth: fidl::encoding::Depth,
6411 ) -> fidl::Result<()> {
6412 encoder.debug_check_bounds::<ObserverWatchPlugStateResponse>(offset);
6413 let max_ordinal: u64 = self.max_ordinal_present();
6415 encoder.write_num(max_ordinal, offset);
6416 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6417 if max_ordinal == 0 {
6419 return Ok(());
6420 }
6421 depth.increment()?;
6422 let envelope_size = 8;
6423 let bytes_len = max_ordinal as usize * envelope_size;
6424 #[allow(unused_variables)]
6425 let offset = encoder.out_of_line_offset(bytes_len);
6426 let mut _prev_end_offset: usize = 0;
6427 if 1 > max_ordinal {
6428 return Ok(());
6429 }
6430
6431 let cur_offset: usize = (1 - 1) * envelope_size;
6434
6435 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6437
6438 fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6443 self.state.as_ref().map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6444 encoder,
6445 offset + cur_offset,
6446 depth,
6447 )?;
6448
6449 _prev_end_offset = cur_offset + envelope_size;
6450 if 2 > max_ordinal {
6451 return Ok(());
6452 }
6453
6454 let cur_offset: usize = (2 - 1) * envelope_size;
6457
6458 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6460
6461 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6466 self.plug_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6467 encoder,
6468 offset + cur_offset,
6469 depth,
6470 )?;
6471
6472 _prev_end_offset = cur_offset + envelope_size;
6473
6474 Ok(())
6475 }
6476 }
6477
6478 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6479 for ObserverWatchPlugStateResponse
6480 {
6481 #[inline(always)]
6482 fn new_empty() -> Self {
6483 Self::default()
6484 }
6485
6486 unsafe fn decode(
6487 &mut self,
6488 decoder: &mut fidl::encoding::Decoder<'_, D>,
6489 offset: usize,
6490 mut depth: fidl::encoding::Depth,
6491 ) -> fidl::Result<()> {
6492 decoder.debug_check_bounds::<Self>(offset);
6493 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6494 None => return Err(fidl::Error::NotNullable),
6495 Some(len) => len,
6496 };
6497 if len == 0 {
6499 return Ok(());
6500 };
6501 depth.increment()?;
6502 let envelope_size = 8;
6503 let bytes_len = len * envelope_size;
6504 let offset = decoder.out_of_line_offset(bytes_len)?;
6505 let mut _next_ordinal_to_read = 0;
6507 let mut next_offset = offset;
6508 let end_offset = offset + bytes_len;
6509 _next_ordinal_to_read += 1;
6510 if next_offset >= end_offset {
6511 return Ok(());
6512 }
6513
6514 while _next_ordinal_to_read < 1 {
6516 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6517 _next_ordinal_to_read += 1;
6518 next_offset += envelope_size;
6519 }
6520
6521 let next_out_of_line = decoder.next_out_of_line();
6522 let handles_before = decoder.remaining_handles();
6523 if let Some((inlined, num_bytes, num_handles)) =
6524 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6525 {
6526 let member_inline_size =
6527 <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6528 if inlined != (member_inline_size <= 4) {
6529 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6530 }
6531 let inner_offset;
6532 let mut inner_depth = depth.clone();
6533 if inlined {
6534 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6535 inner_offset = next_offset;
6536 } else {
6537 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6538 inner_depth.increment()?;
6539 }
6540 let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6541 fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6542 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6543 {
6544 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6545 }
6546 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6547 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6548 }
6549 }
6550
6551 next_offset += envelope_size;
6552 _next_ordinal_to_read += 1;
6553 if next_offset >= end_offset {
6554 return Ok(());
6555 }
6556
6557 while _next_ordinal_to_read < 2 {
6559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6560 _next_ordinal_to_read += 1;
6561 next_offset += envelope_size;
6562 }
6563
6564 let next_out_of_line = decoder.next_out_of_line();
6565 let handles_before = decoder.remaining_handles();
6566 if let Some((inlined, num_bytes, num_handles)) =
6567 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6568 {
6569 let member_inline_size =
6570 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6571 if inlined != (member_inline_size <= 4) {
6572 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6573 }
6574 let inner_offset;
6575 let mut inner_depth = depth.clone();
6576 if inlined {
6577 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6578 inner_offset = next_offset;
6579 } else {
6580 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6581 inner_depth.increment()?;
6582 }
6583 let val_ref = self.plug_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
6584 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6585 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6586 {
6587 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6588 }
6589 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6590 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6591 }
6592 }
6593
6594 next_offset += envelope_size;
6595
6596 while next_offset < end_offset {
6598 _next_ordinal_to_read += 1;
6599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6600 next_offset += envelope_size;
6601 }
6602
6603 Ok(())
6604 }
6605 }
6606
6607 impl PcmFormatSet {
6608 #[inline(always)]
6609 fn max_ordinal_present(&self) -> u64 {
6610 if let Some(_) = self.frame_rates {
6611 return 3;
6612 }
6613 if let Some(_) = self.sample_types {
6614 return 2;
6615 }
6616 if let Some(_) = self.channel_sets {
6617 return 1;
6618 }
6619 0
6620 }
6621 }
6622
6623 impl fidl::encoding::ValueTypeMarker for PcmFormatSet {
6624 type Borrowed<'a> = &'a Self;
6625 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6626 value
6627 }
6628 }
6629
6630 unsafe impl fidl::encoding::TypeMarker for PcmFormatSet {
6631 type Owned = Self;
6632
6633 #[inline(always)]
6634 fn inline_align(_context: fidl::encoding::Context) -> usize {
6635 8
6636 }
6637
6638 #[inline(always)]
6639 fn inline_size(_context: fidl::encoding::Context) -> usize {
6640 16
6641 }
6642 }
6643
6644 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormatSet, D>
6645 for &PcmFormatSet
6646 {
6647 unsafe fn encode(
6648 self,
6649 encoder: &mut fidl::encoding::Encoder<'_, D>,
6650 offset: usize,
6651 mut depth: fidl::encoding::Depth,
6652 ) -> fidl::Result<()> {
6653 encoder.debug_check_bounds::<PcmFormatSet>(offset);
6654 let max_ordinal: u64 = self.max_ordinal_present();
6656 encoder.write_num(max_ordinal, offset);
6657 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6658 if max_ordinal == 0 {
6660 return Ok(());
6661 }
6662 depth.increment()?;
6663 let envelope_size = 8;
6664 let bytes_len = max_ordinal as usize * envelope_size;
6665 #[allow(unused_variables)]
6666 let offset = encoder.out_of_line_offset(bytes_len);
6667 let mut _prev_end_offset: usize = 0;
6668 if 1 > max_ordinal {
6669 return Ok(());
6670 }
6671
6672 let cur_offset: usize = (1 - 1) * envelope_size;
6675
6676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6678
6679 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelSet, 64>, D>(
6684 self.channel_sets.as_ref().map(<fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6685 encoder, offset + cur_offset, depth
6686 )?;
6687
6688 _prev_end_offset = cur_offset + envelope_size;
6689 if 2 > max_ordinal {
6690 return Ok(());
6691 }
6692
6693 let cur_offset: usize = (2 - 1) * envelope_size;
6696
6697 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6699
6700 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D>(
6705 self.sample_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6706 encoder, offset + cur_offset, depth
6707 )?;
6708
6709 _prev_end_offset = cur_offset + envelope_size;
6710 if 3 > max_ordinal {
6711 return Ok(());
6712 }
6713
6714 let cur_offset: usize = (3 - 1) * envelope_size;
6717
6718 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6720
6721 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u32, 64>, D>(
6726 self.frame_rates.as_ref().map(
6727 <fidl::encoding::Vector<u32, 64> as fidl::encoding::ValueTypeMarker>::borrow,
6728 ),
6729 encoder,
6730 offset + cur_offset,
6731 depth,
6732 )?;
6733
6734 _prev_end_offset = cur_offset + envelope_size;
6735
6736 Ok(())
6737 }
6738 }
6739
6740 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormatSet {
6741 #[inline(always)]
6742 fn new_empty() -> Self {
6743 Self::default()
6744 }
6745
6746 unsafe fn decode(
6747 &mut self,
6748 decoder: &mut fidl::encoding::Decoder<'_, D>,
6749 offset: usize,
6750 mut depth: fidl::encoding::Depth,
6751 ) -> fidl::Result<()> {
6752 decoder.debug_check_bounds::<Self>(offset);
6753 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6754 None => return Err(fidl::Error::NotNullable),
6755 Some(len) => len,
6756 };
6757 if len == 0 {
6759 return Ok(());
6760 };
6761 depth.increment()?;
6762 let envelope_size = 8;
6763 let bytes_len = len * envelope_size;
6764 let offset = decoder.out_of_line_offset(bytes_len)?;
6765 let mut _next_ordinal_to_read = 0;
6767 let mut next_offset = offset;
6768 let end_offset = offset + bytes_len;
6769 _next_ordinal_to_read += 1;
6770 if next_offset >= end_offset {
6771 return Ok(());
6772 }
6773
6774 while _next_ordinal_to_read < 1 {
6776 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6777 _next_ordinal_to_read += 1;
6778 next_offset += envelope_size;
6779 }
6780
6781 let next_out_of_line = decoder.next_out_of_line();
6782 let handles_before = decoder.remaining_handles();
6783 if let Some((inlined, num_bytes, num_handles)) =
6784 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6785 {
6786 let member_inline_size = <fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6787 if inlined != (member_inline_size <= 4) {
6788 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6789 }
6790 let inner_offset;
6791 let mut inner_depth = depth.clone();
6792 if inlined {
6793 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6794 inner_offset = next_offset;
6795 } else {
6796 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6797 inner_depth.increment()?;
6798 }
6799 let val_ref = self.channel_sets.get_or_insert_with(
6800 || fidl::new_empty!(fidl::encoding::Vector<ChannelSet, 64>, D),
6801 );
6802 fidl::decode!(fidl::encoding::Vector<ChannelSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6803 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6804 {
6805 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6806 }
6807 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6808 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6809 }
6810 }
6811
6812 next_offset += envelope_size;
6813 _next_ordinal_to_read += 1;
6814 if next_offset >= end_offset {
6815 return Ok(());
6816 }
6817
6818 while _next_ordinal_to_read < 2 {
6820 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6821 _next_ordinal_to_read += 1;
6822 next_offset += envelope_size;
6823 }
6824
6825 let next_out_of_line = decoder.next_out_of_line();
6826 let handles_before = decoder.remaining_handles();
6827 if let Some((inlined, num_bytes, num_handles)) =
6828 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6829 {
6830 let member_inline_size = <fidl::encoding::Vector<
6831 fidl_fuchsia_audio__common::SampleType,
6832 32,
6833 > as fidl::encoding::TypeMarker>::inline_size(
6834 decoder.context
6835 );
6836 if inlined != (member_inline_size <= 4) {
6837 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6838 }
6839 let inner_offset;
6840 let mut inner_depth = depth.clone();
6841 if inlined {
6842 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6843 inner_offset = next_offset;
6844 } else {
6845 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6846 inner_depth.increment()?;
6847 }
6848 let val_ref =
6849 self.sample_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D));
6850 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6851 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6852 {
6853 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6854 }
6855 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6856 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6857 }
6858 }
6859
6860 next_offset += envelope_size;
6861 _next_ordinal_to_read += 1;
6862 if next_offset >= end_offset {
6863 return Ok(());
6864 }
6865
6866 while _next_ordinal_to_read < 3 {
6868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6869 _next_ordinal_to_read += 1;
6870 next_offset += envelope_size;
6871 }
6872
6873 let next_out_of_line = decoder.next_out_of_line();
6874 let handles_before = decoder.remaining_handles();
6875 if let Some((inlined, num_bytes, num_handles)) =
6876 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6877 {
6878 let member_inline_size =
6879 <fidl::encoding::Vector<u32, 64> as fidl::encoding::TypeMarker>::inline_size(
6880 decoder.context,
6881 );
6882 if inlined != (member_inline_size <= 4) {
6883 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6884 }
6885 let inner_offset;
6886 let mut inner_depth = depth.clone();
6887 if inlined {
6888 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6889 inner_offset = next_offset;
6890 } else {
6891 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6892 inner_depth.increment()?;
6893 }
6894 let val_ref = self
6895 .frame_rates
6896 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u32, 64>, D));
6897 fidl::decode!(fidl::encoding::Vector<u32, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6898 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6899 {
6900 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6901 }
6902 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6903 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6904 }
6905 }
6906
6907 next_offset += envelope_size;
6908
6909 while next_offset < end_offset {
6911 _next_ordinal_to_read += 1;
6912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6913 next_offset += envelope_size;
6914 }
6915
6916 Ok(())
6917 }
6918 }
6919
6920 impl ProviderAddDeviceResponse {
6921 #[inline(always)]
6922 fn max_ordinal_present(&self) -> u64 {
6923 0
6924 }
6925 }
6926
6927 impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceResponse {
6928 type Borrowed<'a> = &'a Self;
6929 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6930 value
6931 }
6932 }
6933
6934 unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceResponse {
6935 type Owned = Self;
6936
6937 #[inline(always)]
6938 fn inline_align(_context: fidl::encoding::Context) -> usize {
6939 8
6940 }
6941
6942 #[inline(always)]
6943 fn inline_size(_context: fidl::encoding::Context) -> usize {
6944 16
6945 }
6946 }
6947
6948 unsafe impl<D: fidl::encoding::ResourceDialect>
6949 fidl::encoding::Encode<ProviderAddDeviceResponse, D> for &ProviderAddDeviceResponse
6950 {
6951 unsafe fn encode(
6952 self,
6953 encoder: &mut fidl::encoding::Encoder<'_, D>,
6954 offset: usize,
6955 mut depth: fidl::encoding::Depth,
6956 ) -> fidl::Result<()> {
6957 encoder.debug_check_bounds::<ProviderAddDeviceResponse>(offset);
6958 let max_ordinal: u64 = self.max_ordinal_present();
6960 encoder.write_num(max_ordinal, offset);
6961 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6962 if max_ordinal == 0 {
6964 return Ok(());
6965 }
6966 depth.increment()?;
6967 let envelope_size = 8;
6968 let bytes_len = max_ordinal as usize * envelope_size;
6969 #[allow(unused_variables)]
6970 let offset = encoder.out_of_line_offset(bytes_len);
6971 let mut _prev_end_offset: usize = 0;
6972
6973 Ok(())
6974 }
6975 }
6976
6977 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6978 for ProviderAddDeviceResponse
6979 {
6980 #[inline(always)]
6981 fn new_empty() -> Self {
6982 Self::default()
6983 }
6984
6985 unsafe fn decode(
6986 &mut self,
6987 decoder: &mut fidl::encoding::Decoder<'_, D>,
6988 offset: usize,
6989 mut depth: fidl::encoding::Depth,
6990 ) -> fidl::Result<()> {
6991 decoder.debug_check_bounds::<Self>(offset);
6992 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6993 None => return Err(fidl::Error::NotNullable),
6994 Some(len) => len,
6995 };
6996 if len == 0 {
6998 return Ok(());
6999 };
7000 depth.increment()?;
7001 let envelope_size = 8;
7002 let bytes_len = len * envelope_size;
7003 let offset = decoder.out_of_line_offset(bytes_len)?;
7004 let mut _next_ordinal_to_read = 0;
7006 let mut next_offset = offset;
7007 let end_offset = offset + bytes_len;
7008
7009 while next_offset < end_offset {
7011 _next_ordinal_to_read += 1;
7012 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7013 next_offset += envelope_size;
7014 }
7015
7016 Ok(())
7017 }
7018 }
7019
7020 impl RegistryCreateObserverResponse {
7021 #[inline(always)]
7022 fn max_ordinal_present(&self) -> u64 {
7023 0
7024 }
7025 }
7026
7027 impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverResponse {
7028 type Borrowed<'a> = &'a Self;
7029 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7030 value
7031 }
7032 }
7033
7034 unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverResponse {
7035 type Owned = Self;
7036
7037 #[inline(always)]
7038 fn inline_align(_context: fidl::encoding::Context) -> usize {
7039 8
7040 }
7041
7042 #[inline(always)]
7043 fn inline_size(_context: fidl::encoding::Context) -> usize {
7044 16
7045 }
7046 }
7047
7048 unsafe impl<D: fidl::encoding::ResourceDialect>
7049 fidl::encoding::Encode<RegistryCreateObserverResponse, D>
7050 for &RegistryCreateObserverResponse
7051 {
7052 unsafe fn encode(
7053 self,
7054 encoder: &mut fidl::encoding::Encoder<'_, D>,
7055 offset: usize,
7056 mut depth: fidl::encoding::Depth,
7057 ) -> fidl::Result<()> {
7058 encoder.debug_check_bounds::<RegistryCreateObserverResponse>(offset);
7059 let max_ordinal: u64 = self.max_ordinal_present();
7061 encoder.write_num(max_ordinal, offset);
7062 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7063 if max_ordinal == 0 {
7065 return Ok(());
7066 }
7067 depth.increment()?;
7068 let envelope_size = 8;
7069 let bytes_len = max_ordinal as usize * envelope_size;
7070 #[allow(unused_variables)]
7071 let offset = encoder.out_of_line_offset(bytes_len);
7072 let mut _prev_end_offset: usize = 0;
7073
7074 Ok(())
7075 }
7076 }
7077
7078 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7079 for RegistryCreateObserverResponse
7080 {
7081 #[inline(always)]
7082 fn new_empty() -> Self {
7083 Self::default()
7084 }
7085
7086 unsafe fn decode(
7087 &mut self,
7088 decoder: &mut fidl::encoding::Decoder<'_, D>,
7089 offset: usize,
7090 mut depth: fidl::encoding::Depth,
7091 ) -> fidl::Result<()> {
7092 decoder.debug_check_bounds::<Self>(offset);
7093 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7094 None => return Err(fidl::Error::NotNullable),
7095 Some(len) => len,
7096 };
7097 if len == 0 {
7099 return Ok(());
7100 };
7101 depth.increment()?;
7102 let envelope_size = 8;
7103 let bytes_len = len * envelope_size;
7104 let offset = decoder.out_of_line_offset(bytes_len)?;
7105 let mut _next_ordinal_to_read = 0;
7107 let mut next_offset = offset;
7108 let end_offset = offset + bytes_len;
7109
7110 while next_offset < end_offset {
7112 _next_ordinal_to_read += 1;
7113 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7114 next_offset += envelope_size;
7115 }
7116
7117 Ok(())
7118 }
7119 }
7120
7121 impl RegistryWatchDeviceRemovedResponse {
7122 #[inline(always)]
7123 fn max_ordinal_present(&self) -> u64 {
7124 if let Some(_) = self.token_id {
7125 return 1;
7126 }
7127 0
7128 }
7129 }
7130
7131 impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedResponse {
7132 type Borrowed<'a> = &'a Self;
7133 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7134 value
7135 }
7136 }
7137
7138 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedResponse {
7139 type Owned = Self;
7140
7141 #[inline(always)]
7142 fn inline_align(_context: fidl::encoding::Context) -> usize {
7143 8
7144 }
7145
7146 #[inline(always)]
7147 fn inline_size(_context: fidl::encoding::Context) -> usize {
7148 16
7149 }
7150 }
7151
7152 unsafe impl<D: fidl::encoding::ResourceDialect>
7153 fidl::encoding::Encode<RegistryWatchDeviceRemovedResponse, D>
7154 for &RegistryWatchDeviceRemovedResponse
7155 {
7156 unsafe fn encode(
7157 self,
7158 encoder: &mut fidl::encoding::Encoder<'_, D>,
7159 offset: usize,
7160 mut depth: fidl::encoding::Depth,
7161 ) -> fidl::Result<()> {
7162 encoder.debug_check_bounds::<RegistryWatchDeviceRemovedResponse>(offset);
7163 let max_ordinal: u64 = self.max_ordinal_present();
7165 encoder.write_num(max_ordinal, offset);
7166 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7167 if max_ordinal == 0 {
7169 return Ok(());
7170 }
7171 depth.increment()?;
7172 let envelope_size = 8;
7173 let bytes_len = max_ordinal as usize * envelope_size;
7174 #[allow(unused_variables)]
7175 let offset = encoder.out_of_line_offset(bytes_len);
7176 let mut _prev_end_offset: usize = 0;
7177 if 1 > max_ordinal {
7178 return Ok(());
7179 }
7180
7181 let cur_offset: usize = (1 - 1) * envelope_size;
7184
7185 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7187
7188 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7193 self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7194 encoder,
7195 offset + cur_offset,
7196 depth,
7197 )?;
7198
7199 _prev_end_offset = cur_offset + envelope_size;
7200
7201 Ok(())
7202 }
7203 }
7204
7205 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7206 for RegistryWatchDeviceRemovedResponse
7207 {
7208 #[inline(always)]
7209 fn new_empty() -> Self {
7210 Self::default()
7211 }
7212
7213 unsafe fn decode(
7214 &mut self,
7215 decoder: &mut fidl::encoding::Decoder<'_, D>,
7216 offset: usize,
7217 mut depth: fidl::encoding::Depth,
7218 ) -> fidl::Result<()> {
7219 decoder.debug_check_bounds::<Self>(offset);
7220 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7221 None => return Err(fidl::Error::NotNullable),
7222 Some(len) => len,
7223 };
7224 if len == 0 {
7226 return Ok(());
7227 };
7228 depth.increment()?;
7229 let envelope_size = 8;
7230 let bytes_len = len * envelope_size;
7231 let offset = decoder.out_of_line_offset(bytes_len)?;
7232 let mut _next_ordinal_to_read = 0;
7234 let mut next_offset = offset;
7235 let end_offset = offset + bytes_len;
7236 _next_ordinal_to_read += 1;
7237 if next_offset >= end_offset {
7238 return Ok(());
7239 }
7240
7241 while _next_ordinal_to_read < 1 {
7243 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7244 _next_ordinal_to_read += 1;
7245 next_offset += envelope_size;
7246 }
7247
7248 let next_out_of_line = decoder.next_out_of_line();
7249 let handles_before = decoder.remaining_handles();
7250 if let Some((inlined, num_bytes, num_handles)) =
7251 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7252 {
7253 let member_inline_size =
7254 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7255 if inlined != (member_inline_size <= 4) {
7256 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7257 }
7258 let inner_offset;
7259 let mut inner_depth = depth.clone();
7260 if inlined {
7261 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7262 inner_offset = next_offset;
7263 } else {
7264 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7265 inner_depth.increment()?;
7266 }
7267 let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7268 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7269 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7270 {
7271 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7272 }
7273 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7274 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7275 }
7276 }
7277
7278 next_offset += envelope_size;
7279
7280 while next_offset < end_offset {
7282 _next_ordinal_to_read += 1;
7283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7284 next_offset += envelope_size;
7285 }
7286
7287 Ok(())
7288 }
7289 }
7290
7291 impl RegistryWatchDevicesAddedResponse {
7292 #[inline(always)]
7293 fn max_ordinal_present(&self) -> u64 {
7294 if let Some(_) = self.devices {
7295 return 1;
7296 }
7297 0
7298 }
7299 }
7300
7301 impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedResponse {
7302 type Borrowed<'a> = &'a Self;
7303 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7304 value
7305 }
7306 }
7307
7308 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedResponse {
7309 type Owned = Self;
7310
7311 #[inline(always)]
7312 fn inline_align(_context: fidl::encoding::Context) -> usize {
7313 8
7314 }
7315
7316 #[inline(always)]
7317 fn inline_size(_context: fidl::encoding::Context) -> usize {
7318 16
7319 }
7320 }
7321
7322 unsafe impl<D: fidl::encoding::ResourceDialect>
7323 fidl::encoding::Encode<RegistryWatchDevicesAddedResponse, D>
7324 for &RegistryWatchDevicesAddedResponse
7325 {
7326 unsafe fn encode(
7327 self,
7328 encoder: &mut fidl::encoding::Encoder<'_, D>,
7329 offset: usize,
7330 mut depth: fidl::encoding::Depth,
7331 ) -> fidl::Result<()> {
7332 encoder.debug_check_bounds::<RegistryWatchDevicesAddedResponse>(offset);
7333 let max_ordinal: u64 = self.max_ordinal_present();
7335 encoder.write_num(max_ordinal, offset);
7336 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7337 if max_ordinal == 0 {
7339 return Ok(());
7340 }
7341 depth.increment()?;
7342 let envelope_size = 8;
7343 let bytes_len = max_ordinal as usize * envelope_size;
7344 #[allow(unused_variables)]
7345 let offset = encoder.out_of_line_offset(bytes_len);
7346 let mut _prev_end_offset: usize = 0;
7347 if 1 > max_ordinal {
7348 return Ok(());
7349 }
7350
7351 let cur_offset: usize = (1 - 1) * envelope_size;
7354
7355 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7357
7358 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Info, 256>, D>(
7363 self.devices.as_ref().map(
7364 <fidl::encoding::Vector<Info, 256> as fidl::encoding::ValueTypeMarker>::borrow,
7365 ),
7366 encoder,
7367 offset + cur_offset,
7368 depth,
7369 )?;
7370
7371 _prev_end_offset = cur_offset + envelope_size;
7372
7373 Ok(())
7374 }
7375 }
7376
7377 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7378 for RegistryWatchDevicesAddedResponse
7379 {
7380 #[inline(always)]
7381 fn new_empty() -> Self {
7382 Self::default()
7383 }
7384
7385 unsafe fn decode(
7386 &mut self,
7387 decoder: &mut fidl::encoding::Decoder<'_, D>,
7388 offset: usize,
7389 mut depth: fidl::encoding::Depth,
7390 ) -> fidl::Result<()> {
7391 decoder.debug_check_bounds::<Self>(offset);
7392 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7393 None => return Err(fidl::Error::NotNullable),
7394 Some(len) => len,
7395 };
7396 if len == 0 {
7398 return Ok(());
7399 };
7400 depth.increment()?;
7401 let envelope_size = 8;
7402 let bytes_len = len * envelope_size;
7403 let offset = decoder.out_of_line_offset(bytes_len)?;
7404 let mut _next_ordinal_to_read = 0;
7406 let mut next_offset = offset;
7407 let end_offset = offset + bytes_len;
7408 _next_ordinal_to_read += 1;
7409 if next_offset >= end_offset {
7410 return Ok(());
7411 }
7412
7413 while _next_ordinal_to_read < 1 {
7415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7416 _next_ordinal_to_read += 1;
7417 next_offset += envelope_size;
7418 }
7419
7420 let next_out_of_line = decoder.next_out_of_line();
7421 let handles_before = decoder.remaining_handles();
7422 if let Some((inlined, num_bytes, num_handles)) =
7423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7424 {
7425 let member_inline_size =
7426 <fidl::encoding::Vector<Info, 256> as fidl::encoding::TypeMarker>::inline_size(
7427 decoder.context,
7428 );
7429 if inlined != (member_inline_size <= 4) {
7430 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7431 }
7432 let inner_offset;
7433 let mut inner_depth = depth.clone();
7434 if inlined {
7435 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7436 inner_offset = next_offset;
7437 } else {
7438 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7439 inner_depth.increment()?;
7440 }
7441 let val_ref = self
7442 .devices
7443 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Info, 256>, D));
7444 fidl::decode!(fidl::encoding::Vector<Info, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
7445 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7446 {
7447 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7448 }
7449 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7450 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7451 }
7452 }
7453
7454 next_offset += envelope_size;
7455
7456 while next_offset < end_offset {
7458 _next_ordinal_to_read += 1;
7459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7460 next_offset += envelope_size;
7461 }
7462
7463 Ok(())
7464 }
7465 }
7466
7467 impl RingBufferOptions {
7468 #[inline(always)]
7469 fn max_ordinal_present(&self) -> u64 {
7470 if let Some(_) = self.ring_buffer_min_bytes {
7471 return 2;
7472 }
7473 if let Some(_) = self.format {
7474 return 1;
7475 }
7476 0
7477 }
7478 }
7479
7480 impl fidl::encoding::ValueTypeMarker for RingBufferOptions {
7481 type Borrowed<'a> = &'a Self;
7482 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7483 value
7484 }
7485 }
7486
7487 unsafe impl fidl::encoding::TypeMarker for RingBufferOptions {
7488 type Owned = Self;
7489
7490 #[inline(always)]
7491 fn inline_align(_context: fidl::encoding::Context) -> usize {
7492 8
7493 }
7494
7495 #[inline(always)]
7496 fn inline_size(_context: fidl::encoding::Context) -> usize {
7497 16
7498 }
7499 }
7500
7501 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferOptions, D>
7502 for &RingBufferOptions
7503 {
7504 unsafe fn encode(
7505 self,
7506 encoder: &mut fidl::encoding::Encoder<'_, D>,
7507 offset: usize,
7508 mut depth: fidl::encoding::Depth,
7509 ) -> fidl::Result<()> {
7510 encoder.debug_check_bounds::<RingBufferOptions>(offset);
7511 let max_ordinal: u64 = self.max_ordinal_present();
7513 encoder.write_num(max_ordinal, offset);
7514 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7515 if max_ordinal == 0 {
7517 return Ok(());
7518 }
7519 depth.increment()?;
7520 let envelope_size = 8;
7521 let bytes_len = max_ordinal as usize * envelope_size;
7522 #[allow(unused_variables)]
7523 let offset = encoder.out_of_line_offset(bytes_len);
7524 let mut _prev_end_offset: usize = 0;
7525 if 1 > max_ordinal {
7526 return Ok(());
7527 }
7528
7529 let cur_offset: usize = (1 - 1) * envelope_size;
7532
7533 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7535
7536 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_audio__common::Format, D>(
7541 self.format.as_ref().map(
7542 <fidl_fuchsia_audio__common::Format as fidl::encoding::ValueTypeMarker>::borrow,
7543 ),
7544 encoder,
7545 offset + cur_offset,
7546 depth,
7547 )?;
7548
7549 _prev_end_offset = cur_offset + envelope_size;
7550 if 2 > max_ordinal {
7551 return Ok(());
7552 }
7553
7554 let cur_offset: usize = (2 - 1) * envelope_size;
7557
7558 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7560
7561 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7566 self.ring_buffer_min_bytes
7567 .as_ref()
7568 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7569 encoder,
7570 offset + cur_offset,
7571 depth,
7572 )?;
7573
7574 _prev_end_offset = cur_offset + envelope_size;
7575
7576 Ok(())
7577 }
7578 }
7579
7580 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferOptions {
7581 #[inline(always)]
7582 fn new_empty() -> Self {
7583 Self::default()
7584 }
7585
7586 unsafe fn decode(
7587 &mut self,
7588 decoder: &mut fidl::encoding::Decoder<'_, D>,
7589 offset: usize,
7590 mut depth: fidl::encoding::Depth,
7591 ) -> fidl::Result<()> {
7592 decoder.debug_check_bounds::<Self>(offset);
7593 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7594 None => return Err(fidl::Error::NotNullable),
7595 Some(len) => len,
7596 };
7597 if len == 0 {
7599 return Ok(());
7600 };
7601 depth.increment()?;
7602 let envelope_size = 8;
7603 let bytes_len = len * envelope_size;
7604 let offset = decoder.out_of_line_offset(bytes_len)?;
7605 let mut _next_ordinal_to_read = 0;
7607 let mut next_offset = offset;
7608 let end_offset = offset + bytes_len;
7609 _next_ordinal_to_read += 1;
7610 if next_offset >= end_offset {
7611 return Ok(());
7612 }
7613
7614 while _next_ordinal_to_read < 1 {
7616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7617 _next_ordinal_to_read += 1;
7618 next_offset += envelope_size;
7619 }
7620
7621 let next_out_of_line = decoder.next_out_of_line();
7622 let handles_before = decoder.remaining_handles();
7623 if let Some((inlined, num_bytes, num_handles)) =
7624 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7625 {
7626 let member_inline_size =
7627 <fidl_fuchsia_audio__common::Format as fidl::encoding::TypeMarker>::inline_size(
7628 decoder.context,
7629 );
7630 if inlined != (member_inline_size <= 4) {
7631 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7632 }
7633 let inner_offset;
7634 let mut inner_depth = depth.clone();
7635 if inlined {
7636 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7637 inner_offset = next_offset;
7638 } else {
7639 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7640 inner_depth.increment()?;
7641 }
7642 let val_ref = self
7643 .format
7644 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_audio__common::Format, D));
7645 fidl::decode!(
7646 fidl_fuchsia_audio__common::Format,
7647 D,
7648 val_ref,
7649 decoder,
7650 inner_offset,
7651 inner_depth
7652 )?;
7653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7654 {
7655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7656 }
7657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7659 }
7660 }
7661
7662 next_offset += envelope_size;
7663 _next_ordinal_to_read += 1;
7664 if next_offset >= end_offset {
7665 return Ok(());
7666 }
7667
7668 while _next_ordinal_to_read < 2 {
7670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7671 _next_ordinal_to_read += 1;
7672 next_offset += envelope_size;
7673 }
7674
7675 let next_out_of_line = decoder.next_out_of_line();
7676 let handles_before = decoder.remaining_handles();
7677 if let Some((inlined, num_bytes, num_handles)) =
7678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7679 {
7680 let member_inline_size =
7681 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7682 if inlined != (member_inline_size <= 4) {
7683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7684 }
7685 let inner_offset;
7686 let mut inner_depth = depth.clone();
7687 if inlined {
7688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7689 inner_offset = next_offset;
7690 } else {
7691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7692 inner_depth.increment()?;
7693 }
7694 let val_ref =
7695 self.ring_buffer_min_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
7696 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7697 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7698 {
7699 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7700 }
7701 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7702 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7703 }
7704 }
7705
7706 next_offset += envelope_size;
7707
7708 while next_offset < end_offset {
7710 _next_ordinal_to_read += 1;
7711 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7712 next_offset += envelope_size;
7713 }
7714
7715 Ok(())
7716 }
7717 }
7718
7719 impl RingBufferProperties {
7720 #[inline(always)]
7721 fn max_ordinal_present(&self) -> u64 {
7722 if let Some(_) = self.turn_on_delay {
7723 return 2;
7724 }
7725 if let Some(_) = self.valid_bits_per_sample {
7726 return 1;
7727 }
7728 0
7729 }
7730 }
7731
7732 impl fidl::encoding::ValueTypeMarker for RingBufferProperties {
7733 type Borrowed<'a> = &'a Self;
7734 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7735 value
7736 }
7737 }
7738
7739 unsafe impl fidl::encoding::TypeMarker for RingBufferProperties {
7740 type Owned = Self;
7741
7742 #[inline(always)]
7743 fn inline_align(_context: fidl::encoding::Context) -> usize {
7744 8
7745 }
7746
7747 #[inline(always)]
7748 fn inline_size(_context: fidl::encoding::Context) -> usize {
7749 16
7750 }
7751 }
7752
7753 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferProperties, D>
7754 for &RingBufferProperties
7755 {
7756 unsafe fn encode(
7757 self,
7758 encoder: &mut fidl::encoding::Encoder<'_, D>,
7759 offset: usize,
7760 mut depth: fidl::encoding::Depth,
7761 ) -> fidl::Result<()> {
7762 encoder.debug_check_bounds::<RingBufferProperties>(offset);
7763 let max_ordinal: u64 = self.max_ordinal_present();
7765 encoder.write_num(max_ordinal, offset);
7766 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7767 if max_ordinal == 0 {
7769 return Ok(());
7770 }
7771 depth.increment()?;
7772 let envelope_size = 8;
7773 let bytes_len = max_ordinal as usize * envelope_size;
7774 #[allow(unused_variables)]
7775 let offset = encoder.out_of_line_offset(bytes_len);
7776 let mut _prev_end_offset: usize = 0;
7777 if 1 > max_ordinal {
7778 return Ok(());
7779 }
7780
7781 let cur_offset: usize = (1 - 1) * envelope_size;
7784
7785 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7787
7788 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7793 self.valid_bits_per_sample
7794 .as_ref()
7795 .map(<u8 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 2 > max_ordinal {
7803 return Ok(());
7804 }
7805
7806 let cur_offset: usize = (2 - 1) * envelope_size;
7809
7810 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7812
7813 fidl::encoding::encode_in_envelope_optional::<i64, D>(
7818 self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7819 encoder,
7820 offset + cur_offset,
7821 depth,
7822 )?;
7823
7824 _prev_end_offset = cur_offset + envelope_size;
7825
7826 Ok(())
7827 }
7828 }
7829
7830 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferProperties {
7831 #[inline(always)]
7832 fn new_empty() -> Self {
7833 Self::default()
7834 }
7835
7836 unsafe fn decode(
7837 &mut self,
7838 decoder: &mut fidl::encoding::Decoder<'_, D>,
7839 offset: usize,
7840 mut depth: fidl::encoding::Depth,
7841 ) -> fidl::Result<()> {
7842 decoder.debug_check_bounds::<Self>(offset);
7843 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7844 None => return Err(fidl::Error::NotNullable),
7845 Some(len) => len,
7846 };
7847 if len == 0 {
7849 return Ok(());
7850 };
7851 depth.increment()?;
7852 let envelope_size = 8;
7853 let bytes_len = len * envelope_size;
7854 let offset = decoder.out_of_line_offset(bytes_len)?;
7855 let mut _next_ordinal_to_read = 0;
7857 let mut next_offset = offset;
7858 let end_offset = offset + bytes_len;
7859 _next_ordinal_to_read += 1;
7860 if next_offset >= end_offset {
7861 return Ok(());
7862 }
7863
7864 while _next_ordinal_to_read < 1 {
7866 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7867 _next_ordinal_to_read += 1;
7868 next_offset += envelope_size;
7869 }
7870
7871 let next_out_of_line = decoder.next_out_of_line();
7872 let handles_before = decoder.remaining_handles();
7873 if let Some((inlined, num_bytes, num_handles)) =
7874 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7875 {
7876 let member_inline_size =
7877 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7878 if inlined != (member_inline_size <= 4) {
7879 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7880 }
7881 let inner_offset;
7882 let mut inner_depth = depth.clone();
7883 if inlined {
7884 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7885 inner_offset = next_offset;
7886 } else {
7887 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7888 inner_depth.increment()?;
7889 }
7890 let val_ref =
7891 self.valid_bits_per_sample.get_or_insert_with(|| fidl::new_empty!(u8, D));
7892 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7893 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7894 {
7895 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7896 }
7897 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7898 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7899 }
7900 }
7901
7902 next_offset += envelope_size;
7903 _next_ordinal_to_read += 1;
7904 if next_offset >= end_offset {
7905 return Ok(());
7906 }
7907
7908 while _next_ordinal_to_read < 2 {
7910 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7911 _next_ordinal_to_read += 1;
7912 next_offset += envelope_size;
7913 }
7914
7915 let next_out_of_line = decoder.next_out_of_line();
7916 let handles_before = decoder.remaining_handles();
7917 if let Some((inlined, num_bytes, num_handles)) =
7918 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7919 {
7920 let member_inline_size =
7921 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7922 if inlined != (member_inline_size <= 4) {
7923 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7924 }
7925 let inner_offset;
7926 let mut inner_depth = depth.clone();
7927 if inlined {
7928 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7929 inner_offset = next_offset;
7930 } else {
7931 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7932 inner_depth.increment()?;
7933 }
7934 let val_ref = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
7935 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7936 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7937 {
7938 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7939 }
7940 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7941 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7942 }
7943 }
7944
7945 next_offset += envelope_size;
7946
7947 while next_offset < end_offset {
7949 _next_ordinal_to_read += 1;
7950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7951 next_offset += envelope_size;
7952 }
7953
7954 Ok(())
7955 }
7956 }
7957
7958 impl RingBufferSetActiveChannelsRequest {
7959 #[inline(always)]
7960 fn max_ordinal_present(&self) -> u64 {
7961 if let Some(_) = self.channel_bitmask {
7962 return 1;
7963 }
7964 0
7965 }
7966 }
7967
7968 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsRequest {
7969 type Borrowed<'a> = &'a Self;
7970 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7971 value
7972 }
7973 }
7974
7975 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsRequest {
7976 type Owned = Self;
7977
7978 #[inline(always)]
7979 fn inline_align(_context: fidl::encoding::Context) -> usize {
7980 8
7981 }
7982
7983 #[inline(always)]
7984 fn inline_size(_context: fidl::encoding::Context) -> usize {
7985 16
7986 }
7987 }
7988
7989 unsafe impl<D: fidl::encoding::ResourceDialect>
7990 fidl::encoding::Encode<RingBufferSetActiveChannelsRequest, D>
7991 for &RingBufferSetActiveChannelsRequest
7992 {
7993 unsafe fn encode(
7994 self,
7995 encoder: &mut fidl::encoding::Encoder<'_, D>,
7996 offset: usize,
7997 mut depth: fidl::encoding::Depth,
7998 ) -> fidl::Result<()> {
7999 encoder.debug_check_bounds::<RingBufferSetActiveChannelsRequest>(offset);
8000 let max_ordinal: u64 = self.max_ordinal_present();
8002 encoder.write_num(max_ordinal, offset);
8003 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8004 if max_ordinal == 0 {
8006 return Ok(());
8007 }
8008 depth.increment()?;
8009 let envelope_size = 8;
8010 let bytes_len = max_ordinal as usize * envelope_size;
8011 #[allow(unused_variables)]
8012 let offset = encoder.out_of_line_offset(bytes_len);
8013 let mut _prev_end_offset: usize = 0;
8014 if 1 > max_ordinal {
8015 return Ok(());
8016 }
8017
8018 let cur_offset: usize = (1 - 1) * envelope_size;
8021
8022 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8024
8025 fidl::encoding::encode_in_envelope_optional::<u64, D>(
8030 self.channel_bitmask.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8031 encoder,
8032 offset + cur_offset,
8033 depth,
8034 )?;
8035
8036 _prev_end_offset = cur_offset + envelope_size;
8037
8038 Ok(())
8039 }
8040 }
8041
8042 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8043 for RingBufferSetActiveChannelsRequest
8044 {
8045 #[inline(always)]
8046 fn new_empty() -> Self {
8047 Self::default()
8048 }
8049
8050 unsafe fn decode(
8051 &mut self,
8052 decoder: &mut fidl::encoding::Decoder<'_, D>,
8053 offset: usize,
8054 mut depth: fidl::encoding::Depth,
8055 ) -> fidl::Result<()> {
8056 decoder.debug_check_bounds::<Self>(offset);
8057 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8058 None => return Err(fidl::Error::NotNullable),
8059 Some(len) => len,
8060 };
8061 if len == 0 {
8063 return Ok(());
8064 };
8065 depth.increment()?;
8066 let envelope_size = 8;
8067 let bytes_len = len * envelope_size;
8068 let offset = decoder.out_of_line_offset(bytes_len)?;
8069 let mut _next_ordinal_to_read = 0;
8071 let mut next_offset = offset;
8072 let end_offset = offset + bytes_len;
8073 _next_ordinal_to_read += 1;
8074 if next_offset >= end_offset {
8075 return Ok(());
8076 }
8077
8078 while _next_ordinal_to_read < 1 {
8080 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8081 _next_ordinal_to_read += 1;
8082 next_offset += envelope_size;
8083 }
8084
8085 let next_out_of_line = decoder.next_out_of_line();
8086 let handles_before = decoder.remaining_handles();
8087 if let Some((inlined, num_bytes, num_handles)) =
8088 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8089 {
8090 let member_inline_size =
8091 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8092 if inlined != (member_inline_size <= 4) {
8093 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8094 }
8095 let inner_offset;
8096 let mut inner_depth = depth.clone();
8097 if inlined {
8098 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8099 inner_offset = next_offset;
8100 } else {
8101 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8102 inner_depth.increment()?;
8103 }
8104 let val_ref = self.channel_bitmask.get_or_insert_with(|| fidl::new_empty!(u64, D));
8105 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8106 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8107 {
8108 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8109 }
8110 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8111 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8112 }
8113 }
8114
8115 next_offset += envelope_size;
8116
8117 while next_offset < end_offset {
8119 _next_ordinal_to_read += 1;
8120 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8121 next_offset += envelope_size;
8122 }
8123
8124 Ok(())
8125 }
8126 }
8127
8128 impl RingBufferStartRequest {
8129 #[inline(always)]
8130 fn max_ordinal_present(&self) -> u64 {
8131 0
8132 }
8133 }
8134
8135 impl fidl::encoding::ValueTypeMarker for RingBufferStartRequest {
8136 type Borrowed<'a> = &'a Self;
8137 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8138 value
8139 }
8140 }
8141
8142 unsafe impl fidl::encoding::TypeMarker for RingBufferStartRequest {
8143 type Owned = Self;
8144
8145 #[inline(always)]
8146 fn inline_align(_context: fidl::encoding::Context) -> usize {
8147 8
8148 }
8149
8150 #[inline(always)]
8151 fn inline_size(_context: fidl::encoding::Context) -> usize {
8152 16
8153 }
8154 }
8155
8156 unsafe impl<D: fidl::encoding::ResourceDialect>
8157 fidl::encoding::Encode<RingBufferStartRequest, D> for &RingBufferStartRequest
8158 {
8159 unsafe fn encode(
8160 self,
8161 encoder: &mut fidl::encoding::Encoder<'_, D>,
8162 offset: usize,
8163 mut depth: fidl::encoding::Depth,
8164 ) -> fidl::Result<()> {
8165 encoder.debug_check_bounds::<RingBufferStartRequest>(offset);
8166 let max_ordinal: u64 = self.max_ordinal_present();
8168 encoder.write_num(max_ordinal, offset);
8169 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8170 if max_ordinal == 0 {
8172 return Ok(());
8173 }
8174 depth.increment()?;
8175 let envelope_size = 8;
8176 let bytes_len = max_ordinal as usize * envelope_size;
8177 #[allow(unused_variables)]
8178 let offset = encoder.out_of_line_offset(bytes_len);
8179 let mut _prev_end_offset: usize = 0;
8180
8181 Ok(())
8182 }
8183 }
8184
8185 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8186 for RingBufferStartRequest
8187 {
8188 #[inline(always)]
8189 fn new_empty() -> Self {
8190 Self::default()
8191 }
8192
8193 unsafe fn decode(
8194 &mut self,
8195 decoder: &mut fidl::encoding::Decoder<'_, D>,
8196 offset: usize,
8197 mut depth: fidl::encoding::Depth,
8198 ) -> fidl::Result<()> {
8199 decoder.debug_check_bounds::<Self>(offset);
8200 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8201 None => return Err(fidl::Error::NotNullable),
8202 Some(len) => len,
8203 };
8204 if len == 0 {
8206 return Ok(());
8207 };
8208 depth.increment()?;
8209 let envelope_size = 8;
8210 let bytes_len = len * envelope_size;
8211 let offset = decoder.out_of_line_offset(bytes_len)?;
8212 let mut _next_ordinal_to_read = 0;
8214 let mut next_offset = offset;
8215 let end_offset = offset + bytes_len;
8216
8217 while next_offset < end_offset {
8219 _next_ordinal_to_read += 1;
8220 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8221 next_offset += envelope_size;
8222 }
8223
8224 Ok(())
8225 }
8226 }
8227
8228 impl RingBufferStopRequest {
8229 #[inline(always)]
8230 fn max_ordinal_present(&self) -> u64 {
8231 0
8232 }
8233 }
8234
8235 impl fidl::encoding::ValueTypeMarker for RingBufferStopRequest {
8236 type Borrowed<'a> = &'a Self;
8237 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8238 value
8239 }
8240 }
8241
8242 unsafe impl fidl::encoding::TypeMarker for RingBufferStopRequest {
8243 type Owned = Self;
8244
8245 #[inline(always)]
8246 fn inline_align(_context: fidl::encoding::Context) -> usize {
8247 8
8248 }
8249
8250 #[inline(always)]
8251 fn inline_size(_context: fidl::encoding::Context) -> usize {
8252 16
8253 }
8254 }
8255
8256 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferStopRequest, D>
8257 for &RingBufferStopRequest
8258 {
8259 unsafe fn encode(
8260 self,
8261 encoder: &mut fidl::encoding::Encoder<'_, D>,
8262 offset: usize,
8263 mut depth: fidl::encoding::Depth,
8264 ) -> fidl::Result<()> {
8265 encoder.debug_check_bounds::<RingBufferStopRequest>(offset);
8266 let max_ordinal: u64 = self.max_ordinal_present();
8268 encoder.write_num(max_ordinal, offset);
8269 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8270 if max_ordinal == 0 {
8272 return Ok(());
8273 }
8274 depth.increment()?;
8275 let envelope_size = 8;
8276 let bytes_len = max_ordinal as usize * envelope_size;
8277 #[allow(unused_variables)]
8278 let offset = encoder.out_of_line_offset(bytes_len);
8279 let mut _prev_end_offset: usize = 0;
8280
8281 Ok(())
8282 }
8283 }
8284
8285 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopRequest {
8286 #[inline(always)]
8287 fn new_empty() -> Self {
8288 Self::default()
8289 }
8290
8291 unsafe fn decode(
8292 &mut self,
8293 decoder: &mut fidl::encoding::Decoder<'_, D>,
8294 offset: usize,
8295 mut depth: fidl::encoding::Depth,
8296 ) -> fidl::Result<()> {
8297 decoder.debug_check_bounds::<Self>(offset);
8298 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8299 None => return Err(fidl::Error::NotNullable),
8300 Some(len) => len,
8301 };
8302 if len == 0 {
8304 return Ok(());
8305 };
8306 depth.increment()?;
8307 let envelope_size = 8;
8308 let bytes_len = len * envelope_size;
8309 let offset = decoder.out_of_line_offset(bytes_len)?;
8310 let mut _next_ordinal_to_read = 0;
8312 let mut next_offset = offset;
8313 let end_offset = offset + bytes_len;
8314
8315 while next_offset < end_offset {
8317 _next_ordinal_to_read += 1;
8318 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8319 next_offset += envelope_size;
8320 }
8321
8322 Ok(())
8323 }
8324 }
8325
8326 impl RingBufferSetActiveChannelsResponse {
8327 #[inline(always)]
8328 fn max_ordinal_present(&self) -> u64 {
8329 if let Some(_) = self.set_time {
8330 return 1;
8331 }
8332 0
8333 }
8334 }
8335
8336 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsResponse {
8337 type Borrowed<'a> = &'a Self;
8338 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8339 value
8340 }
8341 }
8342
8343 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsResponse {
8344 type Owned = Self;
8345
8346 #[inline(always)]
8347 fn inline_align(_context: fidl::encoding::Context) -> usize {
8348 8
8349 }
8350
8351 #[inline(always)]
8352 fn inline_size(_context: fidl::encoding::Context) -> usize {
8353 16
8354 }
8355 }
8356
8357 unsafe impl<D: fidl::encoding::ResourceDialect>
8358 fidl::encoding::Encode<RingBufferSetActiveChannelsResponse, D>
8359 for &RingBufferSetActiveChannelsResponse
8360 {
8361 unsafe fn encode(
8362 self,
8363 encoder: &mut fidl::encoding::Encoder<'_, D>,
8364 offset: usize,
8365 mut depth: fidl::encoding::Depth,
8366 ) -> fidl::Result<()> {
8367 encoder.debug_check_bounds::<RingBufferSetActiveChannelsResponse>(offset);
8368 let max_ordinal: u64 = self.max_ordinal_present();
8370 encoder.write_num(max_ordinal, offset);
8371 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8372 if max_ordinal == 0 {
8374 return Ok(());
8375 }
8376 depth.increment()?;
8377 let envelope_size = 8;
8378 let bytes_len = max_ordinal as usize * envelope_size;
8379 #[allow(unused_variables)]
8380 let offset = encoder.out_of_line_offset(bytes_len);
8381 let mut _prev_end_offset: usize = 0;
8382 if 1 > max_ordinal {
8383 return Ok(());
8384 }
8385
8386 let cur_offset: usize = (1 - 1) * envelope_size;
8389
8390 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8392
8393 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8398 self.set_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8399 encoder,
8400 offset + cur_offset,
8401 depth,
8402 )?;
8403
8404 _prev_end_offset = cur_offset + envelope_size;
8405
8406 Ok(())
8407 }
8408 }
8409
8410 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8411 for RingBufferSetActiveChannelsResponse
8412 {
8413 #[inline(always)]
8414 fn new_empty() -> Self {
8415 Self::default()
8416 }
8417
8418 unsafe fn decode(
8419 &mut self,
8420 decoder: &mut fidl::encoding::Decoder<'_, D>,
8421 offset: usize,
8422 mut depth: fidl::encoding::Depth,
8423 ) -> fidl::Result<()> {
8424 decoder.debug_check_bounds::<Self>(offset);
8425 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8426 None => return Err(fidl::Error::NotNullable),
8427 Some(len) => len,
8428 };
8429 if len == 0 {
8431 return Ok(());
8432 };
8433 depth.increment()?;
8434 let envelope_size = 8;
8435 let bytes_len = len * envelope_size;
8436 let offset = decoder.out_of_line_offset(bytes_len)?;
8437 let mut _next_ordinal_to_read = 0;
8439 let mut next_offset = offset;
8440 let end_offset = offset + bytes_len;
8441 _next_ordinal_to_read += 1;
8442 if next_offset >= end_offset {
8443 return Ok(());
8444 }
8445
8446 while _next_ordinal_to_read < 1 {
8448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8449 _next_ordinal_to_read += 1;
8450 next_offset += envelope_size;
8451 }
8452
8453 let next_out_of_line = decoder.next_out_of_line();
8454 let handles_before = decoder.remaining_handles();
8455 if let Some((inlined, num_bytes, num_handles)) =
8456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8457 {
8458 let member_inline_size =
8459 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8460 if inlined != (member_inline_size <= 4) {
8461 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8462 }
8463 let inner_offset;
8464 let mut inner_depth = depth.clone();
8465 if inlined {
8466 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8467 inner_offset = next_offset;
8468 } else {
8469 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8470 inner_depth.increment()?;
8471 }
8472 let val_ref = self.set_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8473 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8475 {
8476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8477 }
8478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8480 }
8481 }
8482
8483 next_offset += envelope_size;
8484
8485 while next_offset < end_offset {
8487 _next_ordinal_to_read += 1;
8488 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8489 next_offset += envelope_size;
8490 }
8491
8492 Ok(())
8493 }
8494 }
8495
8496 impl RingBufferStartResponse {
8497 #[inline(always)]
8498 fn max_ordinal_present(&self) -> u64 {
8499 if let Some(_) = self.start_time {
8500 return 1;
8501 }
8502 0
8503 }
8504 }
8505
8506 impl fidl::encoding::ValueTypeMarker for RingBufferStartResponse {
8507 type Borrowed<'a> = &'a Self;
8508 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8509 value
8510 }
8511 }
8512
8513 unsafe impl fidl::encoding::TypeMarker for RingBufferStartResponse {
8514 type Owned = Self;
8515
8516 #[inline(always)]
8517 fn inline_align(_context: fidl::encoding::Context) -> usize {
8518 8
8519 }
8520
8521 #[inline(always)]
8522 fn inline_size(_context: fidl::encoding::Context) -> usize {
8523 16
8524 }
8525 }
8526
8527 unsafe impl<D: fidl::encoding::ResourceDialect>
8528 fidl::encoding::Encode<RingBufferStartResponse, D> for &RingBufferStartResponse
8529 {
8530 unsafe fn encode(
8531 self,
8532 encoder: &mut fidl::encoding::Encoder<'_, D>,
8533 offset: usize,
8534 mut depth: fidl::encoding::Depth,
8535 ) -> fidl::Result<()> {
8536 encoder.debug_check_bounds::<RingBufferStartResponse>(offset);
8537 let max_ordinal: u64 = self.max_ordinal_present();
8539 encoder.write_num(max_ordinal, offset);
8540 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8541 if max_ordinal == 0 {
8543 return Ok(());
8544 }
8545 depth.increment()?;
8546 let envelope_size = 8;
8547 let bytes_len = max_ordinal as usize * envelope_size;
8548 #[allow(unused_variables)]
8549 let offset = encoder.out_of_line_offset(bytes_len);
8550 let mut _prev_end_offset: usize = 0;
8551 if 1 > max_ordinal {
8552 return Ok(());
8553 }
8554
8555 let cur_offset: usize = (1 - 1) * envelope_size;
8558
8559 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8561
8562 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8567 self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8568 encoder,
8569 offset + cur_offset,
8570 depth,
8571 )?;
8572
8573 _prev_end_offset = cur_offset + envelope_size;
8574
8575 Ok(())
8576 }
8577 }
8578
8579 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8580 for RingBufferStartResponse
8581 {
8582 #[inline(always)]
8583 fn new_empty() -> Self {
8584 Self::default()
8585 }
8586
8587 unsafe fn decode(
8588 &mut self,
8589 decoder: &mut fidl::encoding::Decoder<'_, D>,
8590 offset: usize,
8591 mut depth: fidl::encoding::Depth,
8592 ) -> fidl::Result<()> {
8593 decoder.debug_check_bounds::<Self>(offset);
8594 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8595 None => return Err(fidl::Error::NotNullable),
8596 Some(len) => len,
8597 };
8598 if len == 0 {
8600 return Ok(());
8601 };
8602 depth.increment()?;
8603 let envelope_size = 8;
8604 let bytes_len = len * envelope_size;
8605 let offset = decoder.out_of_line_offset(bytes_len)?;
8606 let mut _next_ordinal_to_read = 0;
8608 let mut next_offset = offset;
8609 let end_offset = offset + bytes_len;
8610 _next_ordinal_to_read += 1;
8611 if next_offset >= end_offset {
8612 return Ok(());
8613 }
8614
8615 while _next_ordinal_to_read < 1 {
8617 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8618 _next_ordinal_to_read += 1;
8619 next_offset += envelope_size;
8620 }
8621
8622 let next_out_of_line = decoder.next_out_of_line();
8623 let handles_before = decoder.remaining_handles();
8624 if let Some((inlined, num_bytes, num_handles)) =
8625 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8626 {
8627 let member_inline_size =
8628 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8629 if inlined != (member_inline_size <= 4) {
8630 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8631 }
8632 let inner_offset;
8633 let mut inner_depth = depth.clone();
8634 if inlined {
8635 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8636 inner_offset = next_offset;
8637 } else {
8638 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8639 inner_depth.increment()?;
8640 }
8641 let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8642 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8643 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8644 {
8645 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8646 }
8647 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8648 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8649 }
8650 }
8651
8652 next_offset += envelope_size;
8653
8654 while next_offset < end_offset {
8656 _next_ordinal_to_read += 1;
8657 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8658 next_offset += envelope_size;
8659 }
8660
8661 Ok(())
8662 }
8663 }
8664
8665 impl RingBufferStopResponse {
8666 #[inline(always)]
8667 fn max_ordinal_present(&self) -> u64 {
8668 0
8669 }
8670 }
8671
8672 impl fidl::encoding::ValueTypeMarker for RingBufferStopResponse {
8673 type Borrowed<'a> = &'a Self;
8674 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8675 value
8676 }
8677 }
8678
8679 unsafe impl fidl::encoding::TypeMarker for RingBufferStopResponse {
8680 type Owned = Self;
8681
8682 #[inline(always)]
8683 fn inline_align(_context: fidl::encoding::Context) -> usize {
8684 8
8685 }
8686
8687 #[inline(always)]
8688 fn inline_size(_context: fidl::encoding::Context) -> usize {
8689 16
8690 }
8691 }
8692
8693 unsafe impl<D: fidl::encoding::ResourceDialect>
8694 fidl::encoding::Encode<RingBufferStopResponse, D> for &RingBufferStopResponse
8695 {
8696 unsafe fn encode(
8697 self,
8698 encoder: &mut fidl::encoding::Encoder<'_, D>,
8699 offset: usize,
8700 mut depth: fidl::encoding::Depth,
8701 ) -> fidl::Result<()> {
8702 encoder.debug_check_bounds::<RingBufferStopResponse>(offset);
8703 let max_ordinal: u64 = self.max_ordinal_present();
8705 encoder.write_num(max_ordinal, offset);
8706 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8707 if max_ordinal == 0 {
8709 return Ok(());
8710 }
8711 depth.increment()?;
8712 let envelope_size = 8;
8713 let bytes_len = max_ordinal as usize * envelope_size;
8714 #[allow(unused_variables)]
8715 let offset = encoder.out_of_line_offset(bytes_len);
8716 let mut _prev_end_offset: usize = 0;
8717
8718 Ok(())
8719 }
8720 }
8721
8722 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8723 for RingBufferStopResponse
8724 {
8725 #[inline(always)]
8726 fn new_empty() -> Self {
8727 Self::default()
8728 }
8729
8730 unsafe fn decode(
8731 &mut self,
8732 decoder: &mut fidl::encoding::Decoder<'_, D>,
8733 offset: usize,
8734 mut depth: fidl::encoding::Depth,
8735 ) -> fidl::Result<()> {
8736 decoder.debug_check_bounds::<Self>(offset);
8737 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8738 None => return Err(fidl::Error::NotNullable),
8739 Some(len) => len,
8740 };
8741 if len == 0 {
8743 return Ok(());
8744 };
8745 depth.increment()?;
8746 let envelope_size = 8;
8747 let bytes_len = len * envelope_size;
8748 let offset = decoder.out_of_line_offset(bytes_len)?;
8749 let mut _next_ordinal_to_read = 0;
8751 let mut next_offset = offset;
8752 let end_offset = offset + bytes_len;
8753
8754 while next_offset < end_offset {
8756 _next_ordinal_to_read += 1;
8757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8758 next_offset += envelope_size;
8759 }
8760
8761 Ok(())
8762 }
8763 }
8764
8765 impl RingBufferWatchDelayInfoResponse {
8766 #[inline(always)]
8767 fn max_ordinal_present(&self) -> u64 {
8768 if let Some(_) = self.delay_info {
8769 return 1;
8770 }
8771 0
8772 }
8773 }
8774
8775 impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoResponse {
8776 type Borrowed<'a> = &'a Self;
8777 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8778 value
8779 }
8780 }
8781
8782 unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoResponse {
8783 type Owned = Self;
8784
8785 #[inline(always)]
8786 fn inline_align(_context: fidl::encoding::Context) -> usize {
8787 8
8788 }
8789
8790 #[inline(always)]
8791 fn inline_size(_context: fidl::encoding::Context) -> usize {
8792 16
8793 }
8794 }
8795
8796 unsafe impl<D: fidl::encoding::ResourceDialect>
8797 fidl::encoding::Encode<RingBufferWatchDelayInfoResponse, D>
8798 for &RingBufferWatchDelayInfoResponse
8799 {
8800 unsafe fn encode(
8801 self,
8802 encoder: &mut fidl::encoding::Encoder<'_, D>,
8803 offset: usize,
8804 mut depth: fidl::encoding::Depth,
8805 ) -> fidl::Result<()> {
8806 encoder.debug_check_bounds::<RingBufferWatchDelayInfoResponse>(offset);
8807 let max_ordinal: u64 = self.max_ordinal_present();
8809 encoder.write_num(max_ordinal, offset);
8810 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8811 if max_ordinal == 0 {
8813 return Ok(());
8814 }
8815 depth.increment()?;
8816 let envelope_size = 8;
8817 let bytes_len = max_ordinal as usize * envelope_size;
8818 #[allow(unused_variables)]
8819 let offset = encoder.out_of_line_offset(bytes_len);
8820 let mut _prev_end_offset: usize = 0;
8821 if 1 > max_ordinal {
8822 return Ok(());
8823 }
8824
8825 let cur_offset: usize = (1 - 1) * envelope_size;
8828
8829 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8831
8832 fidl::encoding::encode_in_envelope_optional::<DelayInfo, D>(
8837 self.delay_info
8838 .as_ref()
8839 .map(<DelayInfo as fidl::encoding::ValueTypeMarker>::borrow),
8840 encoder,
8841 offset + cur_offset,
8842 depth,
8843 )?;
8844
8845 _prev_end_offset = cur_offset + envelope_size;
8846
8847 Ok(())
8848 }
8849 }
8850
8851 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8852 for RingBufferWatchDelayInfoResponse
8853 {
8854 #[inline(always)]
8855 fn new_empty() -> Self {
8856 Self::default()
8857 }
8858
8859 unsafe fn decode(
8860 &mut self,
8861 decoder: &mut fidl::encoding::Decoder<'_, D>,
8862 offset: usize,
8863 mut depth: fidl::encoding::Depth,
8864 ) -> fidl::Result<()> {
8865 decoder.debug_check_bounds::<Self>(offset);
8866 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8867 None => return Err(fidl::Error::NotNullable),
8868 Some(len) => len,
8869 };
8870 if len == 0 {
8872 return Ok(());
8873 };
8874 depth.increment()?;
8875 let envelope_size = 8;
8876 let bytes_len = len * envelope_size;
8877 let offset = decoder.out_of_line_offset(bytes_len)?;
8878 let mut _next_ordinal_to_read = 0;
8880 let mut next_offset = offset;
8881 let end_offset = offset + bytes_len;
8882 _next_ordinal_to_read += 1;
8883 if next_offset >= end_offset {
8884 return Ok(());
8885 }
8886
8887 while _next_ordinal_to_read < 1 {
8889 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8890 _next_ordinal_to_read += 1;
8891 next_offset += envelope_size;
8892 }
8893
8894 let next_out_of_line = decoder.next_out_of_line();
8895 let handles_before = decoder.remaining_handles();
8896 if let Some((inlined, num_bytes, num_handles)) =
8897 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8898 {
8899 let member_inline_size =
8900 <DelayInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8901 if inlined != (member_inline_size <= 4) {
8902 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8903 }
8904 let inner_offset;
8905 let mut inner_depth = depth.clone();
8906 if inlined {
8907 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8908 inner_offset = next_offset;
8909 } else {
8910 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8911 inner_depth.increment()?;
8912 }
8913 let val_ref = self.delay_info.get_or_insert_with(|| fidl::new_empty!(DelayInfo, D));
8914 fidl::decode!(DelayInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
8915 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8916 {
8917 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8918 }
8919 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8920 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8921 }
8922 }
8923
8924 next_offset += envelope_size;
8925
8926 while next_offset < end_offset {
8928 _next_ordinal_to_read += 1;
8929 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8930 next_offset += envelope_size;
8931 }
8932
8933 Ok(())
8934 }
8935 }
8936}