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
1843mod internal {
1844 use super::*;
1845 unsafe impl fidl::encoding::TypeMarker for ControlCodecStartError {
1846 type Owned = Self;
1847
1848 #[inline(always)]
1849 fn inline_align(_context: fidl::encoding::Context) -> usize {
1850 std::mem::align_of::<u32>()
1851 }
1852
1853 #[inline(always)]
1854 fn inline_size(_context: fidl::encoding::Context) -> usize {
1855 std::mem::size_of::<u32>()
1856 }
1857
1858 #[inline(always)]
1859 fn encode_is_copy() -> bool {
1860 false
1861 }
1862
1863 #[inline(always)]
1864 fn decode_is_copy() -> bool {
1865 false
1866 }
1867 }
1868
1869 impl fidl::encoding::ValueTypeMarker for ControlCodecStartError {
1870 type Borrowed<'a> = Self;
1871 #[inline(always)]
1872 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1873 *value
1874 }
1875 }
1876
1877 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1878 for ControlCodecStartError
1879 {
1880 #[inline]
1881 unsafe fn encode(
1882 self,
1883 encoder: &mut fidl::encoding::Encoder<'_, D>,
1884 offset: usize,
1885 _depth: fidl::encoding::Depth,
1886 ) -> fidl::Result<()> {
1887 encoder.debug_check_bounds::<Self>(offset);
1888 encoder.write_num(self.into_primitive(), offset);
1889 Ok(())
1890 }
1891 }
1892
1893 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1894 for ControlCodecStartError
1895 {
1896 #[inline(always)]
1897 fn new_empty() -> Self {
1898 Self::unknown()
1899 }
1900
1901 #[inline]
1902 unsafe fn decode(
1903 &mut self,
1904 decoder: &mut fidl::encoding::Decoder<'_, D>,
1905 offset: usize,
1906 _depth: fidl::encoding::Depth,
1907 ) -> fidl::Result<()> {
1908 decoder.debug_check_bounds::<Self>(offset);
1909 let prim = decoder.read_num::<u32>(offset);
1910
1911 *self = Self::from_primitive_allow_unknown(prim);
1912 Ok(())
1913 }
1914 }
1915 unsafe impl fidl::encoding::TypeMarker for ControlCodecStopError {
1916 type Owned = Self;
1917
1918 #[inline(always)]
1919 fn inline_align(_context: fidl::encoding::Context) -> usize {
1920 std::mem::align_of::<u32>()
1921 }
1922
1923 #[inline(always)]
1924 fn inline_size(_context: fidl::encoding::Context) -> usize {
1925 std::mem::size_of::<u32>()
1926 }
1927
1928 #[inline(always)]
1929 fn encode_is_copy() -> bool {
1930 false
1931 }
1932
1933 #[inline(always)]
1934 fn decode_is_copy() -> bool {
1935 false
1936 }
1937 }
1938
1939 impl fidl::encoding::ValueTypeMarker for ControlCodecStopError {
1940 type Borrowed<'a> = Self;
1941 #[inline(always)]
1942 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1943 *value
1944 }
1945 }
1946
1947 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1948 for ControlCodecStopError
1949 {
1950 #[inline]
1951 unsafe fn encode(
1952 self,
1953 encoder: &mut fidl::encoding::Encoder<'_, D>,
1954 offset: usize,
1955 _depth: fidl::encoding::Depth,
1956 ) -> fidl::Result<()> {
1957 encoder.debug_check_bounds::<Self>(offset);
1958 encoder.write_num(self.into_primitive(), offset);
1959 Ok(())
1960 }
1961 }
1962
1963 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCodecStopError {
1964 #[inline(always)]
1965 fn new_empty() -> Self {
1966 Self::unknown()
1967 }
1968
1969 #[inline]
1970 unsafe fn decode(
1971 &mut self,
1972 decoder: &mut fidl::encoding::Decoder<'_, D>,
1973 offset: usize,
1974 _depth: fidl::encoding::Depth,
1975 ) -> fidl::Result<()> {
1976 decoder.debug_check_bounds::<Self>(offset);
1977 let prim = decoder.read_num::<u32>(offset);
1978
1979 *self = Self::from_primitive_allow_unknown(prim);
1980 Ok(())
1981 }
1982 }
1983 unsafe impl fidl::encoding::TypeMarker for ControlCreateRingBufferError {
1984 type Owned = Self;
1985
1986 #[inline(always)]
1987 fn inline_align(_context: fidl::encoding::Context) -> usize {
1988 std::mem::align_of::<u32>()
1989 }
1990
1991 #[inline(always)]
1992 fn inline_size(_context: fidl::encoding::Context) -> usize {
1993 std::mem::size_of::<u32>()
1994 }
1995
1996 #[inline(always)]
1997 fn encode_is_copy() -> bool {
1998 false
1999 }
2000
2001 #[inline(always)]
2002 fn decode_is_copy() -> bool {
2003 false
2004 }
2005 }
2006
2007 impl fidl::encoding::ValueTypeMarker for ControlCreateRingBufferError {
2008 type Borrowed<'a> = Self;
2009 #[inline(always)]
2010 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2011 *value
2012 }
2013 }
2014
2015 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2016 for ControlCreateRingBufferError
2017 {
2018 #[inline]
2019 unsafe fn encode(
2020 self,
2021 encoder: &mut fidl::encoding::Encoder<'_, D>,
2022 offset: usize,
2023 _depth: fidl::encoding::Depth,
2024 ) -> fidl::Result<()> {
2025 encoder.debug_check_bounds::<Self>(offset);
2026 encoder.write_num(self.into_primitive(), offset);
2027 Ok(())
2028 }
2029 }
2030
2031 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2032 for ControlCreateRingBufferError
2033 {
2034 #[inline(always)]
2035 fn new_empty() -> Self {
2036 Self::unknown()
2037 }
2038
2039 #[inline]
2040 unsafe fn decode(
2041 &mut self,
2042 decoder: &mut fidl::encoding::Decoder<'_, D>,
2043 offset: usize,
2044 _depth: fidl::encoding::Depth,
2045 ) -> fidl::Result<()> {
2046 decoder.debug_check_bounds::<Self>(offset);
2047 let prim = decoder.read_num::<u32>(offset);
2048
2049 *self = Self::from_primitive_allow_unknown(prim);
2050 Ok(())
2051 }
2052 }
2053 unsafe impl fidl::encoding::TypeMarker for ControlCreatorError {
2054 type Owned = Self;
2055
2056 #[inline(always)]
2057 fn inline_align(_context: fidl::encoding::Context) -> usize {
2058 std::mem::align_of::<u32>()
2059 }
2060
2061 #[inline(always)]
2062 fn inline_size(_context: fidl::encoding::Context) -> usize {
2063 std::mem::size_of::<u32>()
2064 }
2065
2066 #[inline(always)]
2067 fn encode_is_copy() -> bool {
2068 false
2069 }
2070
2071 #[inline(always)]
2072 fn decode_is_copy() -> bool {
2073 false
2074 }
2075 }
2076
2077 impl fidl::encoding::ValueTypeMarker for ControlCreatorError {
2078 type Borrowed<'a> = Self;
2079 #[inline(always)]
2080 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2081 *value
2082 }
2083 }
2084
2085 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2086 for ControlCreatorError
2087 {
2088 #[inline]
2089 unsafe fn encode(
2090 self,
2091 encoder: &mut fidl::encoding::Encoder<'_, D>,
2092 offset: usize,
2093 _depth: fidl::encoding::Depth,
2094 ) -> fidl::Result<()> {
2095 encoder.debug_check_bounds::<Self>(offset);
2096 encoder.write_num(self.into_primitive(), offset);
2097 Ok(())
2098 }
2099 }
2100
2101 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCreatorError {
2102 #[inline(always)]
2103 fn new_empty() -> Self {
2104 Self::unknown()
2105 }
2106
2107 #[inline]
2108 unsafe fn decode(
2109 &mut self,
2110 decoder: &mut fidl::encoding::Decoder<'_, D>,
2111 offset: usize,
2112 _depth: fidl::encoding::Depth,
2113 ) -> fidl::Result<()> {
2114 decoder.debug_check_bounds::<Self>(offset);
2115 let prim = decoder.read_num::<u32>(offset);
2116
2117 *self = Self::from_primitive_allow_unknown(prim);
2118 Ok(())
2119 }
2120 }
2121 unsafe impl fidl::encoding::TypeMarker for ControlResetError {
2122 type Owned = Self;
2123
2124 #[inline(always)]
2125 fn inline_align(_context: fidl::encoding::Context) -> usize {
2126 std::mem::align_of::<u32>()
2127 }
2128
2129 #[inline(always)]
2130 fn inline_size(_context: fidl::encoding::Context) -> usize {
2131 std::mem::size_of::<u32>()
2132 }
2133
2134 #[inline(always)]
2135 fn encode_is_copy() -> bool {
2136 false
2137 }
2138
2139 #[inline(always)]
2140 fn decode_is_copy() -> bool {
2141 false
2142 }
2143 }
2144
2145 impl fidl::encoding::ValueTypeMarker for ControlResetError {
2146 type Borrowed<'a> = Self;
2147 #[inline(always)]
2148 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2149 *value
2150 }
2151 }
2152
2153 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2154 for ControlResetError
2155 {
2156 #[inline]
2157 unsafe fn encode(
2158 self,
2159 encoder: &mut fidl::encoding::Encoder<'_, D>,
2160 offset: usize,
2161 _depth: fidl::encoding::Depth,
2162 ) -> fidl::Result<()> {
2163 encoder.debug_check_bounds::<Self>(offset);
2164 encoder.write_num(self.into_primitive(), offset);
2165 Ok(())
2166 }
2167 }
2168
2169 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetError {
2170 #[inline(always)]
2171 fn new_empty() -> Self {
2172 Self::unknown()
2173 }
2174
2175 #[inline]
2176 unsafe fn decode(
2177 &mut self,
2178 decoder: &mut fidl::encoding::Decoder<'_, D>,
2179 offset: usize,
2180 _depth: fidl::encoding::Depth,
2181 ) -> fidl::Result<()> {
2182 decoder.debug_check_bounds::<Self>(offset);
2183 let prim = decoder.read_num::<u32>(offset);
2184
2185 *self = Self::from_primitive_allow_unknown(prim);
2186 Ok(())
2187 }
2188 }
2189 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatError {
2190 type Owned = Self;
2191
2192 #[inline(always)]
2193 fn inline_align(_context: fidl::encoding::Context) -> usize {
2194 std::mem::align_of::<u32>()
2195 }
2196
2197 #[inline(always)]
2198 fn inline_size(_context: fidl::encoding::Context) -> usize {
2199 std::mem::size_of::<u32>()
2200 }
2201
2202 #[inline(always)]
2203 fn encode_is_copy() -> bool {
2204 false
2205 }
2206
2207 #[inline(always)]
2208 fn decode_is_copy() -> bool {
2209 false
2210 }
2211 }
2212
2213 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatError {
2214 type Borrowed<'a> = Self;
2215 #[inline(always)]
2216 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2217 *value
2218 }
2219 }
2220
2221 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2222 for ControlSetDaiFormatError
2223 {
2224 #[inline]
2225 unsafe fn encode(
2226 self,
2227 encoder: &mut fidl::encoding::Encoder<'_, D>,
2228 offset: usize,
2229 _depth: fidl::encoding::Depth,
2230 ) -> fidl::Result<()> {
2231 encoder.debug_check_bounds::<Self>(offset);
2232 encoder.write_num(self.into_primitive(), offset);
2233 Ok(())
2234 }
2235 }
2236
2237 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2238 for ControlSetDaiFormatError
2239 {
2240 #[inline(always)]
2241 fn new_empty() -> Self {
2242 Self::unknown()
2243 }
2244
2245 #[inline]
2246 unsafe fn decode(
2247 &mut self,
2248 decoder: &mut fidl::encoding::Decoder<'_, D>,
2249 offset: usize,
2250 _depth: fidl::encoding::Depth,
2251 ) -> fidl::Result<()> {
2252 decoder.debug_check_bounds::<Self>(offset);
2253 let prim = decoder.read_num::<u32>(offset);
2254
2255 *self = Self::from_primitive_allow_unknown(prim);
2256 Ok(())
2257 }
2258 }
2259 unsafe impl fidl::encoding::TypeMarker for DeviceType {
2260 type Owned = Self;
2261
2262 #[inline(always)]
2263 fn inline_align(_context: fidl::encoding::Context) -> usize {
2264 std::mem::align_of::<u32>()
2265 }
2266
2267 #[inline(always)]
2268 fn inline_size(_context: fidl::encoding::Context) -> usize {
2269 std::mem::size_of::<u32>()
2270 }
2271
2272 #[inline(always)]
2273 fn encode_is_copy() -> bool {
2274 false
2275 }
2276
2277 #[inline(always)]
2278 fn decode_is_copy() -> bool {
2279 false
2280 }
2281 }
2282
2283 impl fidl::encoding::ValueTypeMarker for DeviceType {
2284 type Borrowed<'a> = Self;
2285 #[inline(always)]
2286 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2287 *value
2288 }
2289 }
2290
2291 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
2292 #[inline]
2293 unsafe fn encode(
2294 self,
2295 encoder: &mut fidl::encoding::Encoder<'_, D>,
2296 offset: usize,
2297 _depth: fidl::encoding::Depth,
2298 ) -> fidl::Result<()> {
2299 encoder.debug_check_bounds::<Self>(offset);
2300 encoder.write_num(self.into_primitive(), offset);
2301 Ok(())
2302 }
2303 }
2304
2305 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
2306 #[inline(always)]
2307 fn new_empty() -> Self {
2308 Self::unknown()
2309 }
2310
2311 #[inline]
2312 unsafe fn decode(
2313 &mut self,
2314 decoder: &mut fidl::encoding::Decoder<'_, D>,
2315 offset: usize,
2316 _depth: fidl::encoding::Depth,
2317 ) -> fidl::Result<()> {
2318 decoder.debug_check_bounds::<Self>(offset);
2319 let prim = decoder.read_num::<u32>(offset);
2320
2321 *self = Self::from_primitive_allow_unknown(prim);
2322 Ok(())
2323 }
2324 }
2325 unsafe impl fidl::encoding::TypeMarker for ObserverGetReferenceClockError {
2326 type Owned = Self;
2327
2328 #[inline(always)]
2329 fn inline_align(_context: fidl::encoding::Context) -> usize {
2330 std::mem::align_of::<u32>()
2331 }
2332
2333 #[inline(always)]
2334 fn inline_size(_context: fidl::encoding::Context) -> usize {
2335 std::mem::size_of::<u32>()
2336 }
2337
2338 #[inline(always)]
2339 fn encode_is_copy() -> bool {
2340 false
2341 }
2342
2343 #[inline(always)]
2344 fn decode_is_copy() -> bool {
2345 false
2346 }
2347 }
2348
2349 impl fidl::encoding::ValueTypeMarker for ObserverGetReferenceClockError {
2350 type Borrowed<'a> = Self;
2351 #[inline(always)]
2352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2353 *value
2354 }
2355 }
2356
2357 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2358 for ObserverGetReferenceClockError
2359 {
2360 #[inline]
2361 unsafe fn encode(
2362 self,
2363 encoder: &mut fidl::encoding::Encoder<'_, D>,
2364 offset: usize,
2365 _depth: fidl::encoding::Depth,
2366 ) -> fidl::Result<()> {
2367 encoder.debug_check_bounds::<Self>(offset);
2368 encoder.write_num(self.into_primitive(), offset);
2369 Ok(())
2370 }
2371 }
2372
2373 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2374 for ObserverGetReferenceClockError
2375 {
2376 #[inline(always)]
2377 fn new_empty() -> Self {
2378 Self::unknown()
2379 }
2380
2381 #[inline]
2382 unsafe fn decode(
2383 &mut self,
2384 decoder: &mut fidl::encoding::Decoder<'_, D>,
2385 offset: usize,
2386 _depth: fidl::encoding::Depth,
2387 ) -> fidl::Result<()> {
2388 decoder.debug_check_bounds::<Self>(offset);
2389 let prim = decoder.read_num::<u32>(offset);
2390
2391 *self = Self::from_primitive_allow_unknown(prim);
2392 Ok(())
2393 }
2394 }
2395 unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateError {
2396 type Owned = Self;
2397
2398 #[inline(always)]
2399 fn inline_align(_context: fidl::encoding::Context) -> usize {
2400 std::mem::align_of::<u32>()
2401 }
2402
2403 #[inline(always)]
2404 fn inline_size(_context: fidl::encoding::Context) -> usize {
2405 std::mem::size_of::<u32>()
2406 }
2407
2408 #[inline(always)]
2409 fn encode_is_copy() -> bool {
2410 false
2411 }
2412
2413 #[inline(always)]
2414 fn decode_is_copy() -> bool {
2415 false
2416 }
2417 }
2418
2419 impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateError {
2420 type Borrowed<'a> = Self;
2421 #[inline(always)]
2422 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2423 *value
2424 }
2425 }
2426
2427 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2428 for ObserverWatchPlugStateError
2429 {
2430 #[inline]
2431 unsafe fn encode(
2432 self,
2433 encoder: &mut fidl::encoding::Encoder<'_, D>,
2434 offset: usize,
2435 _depth: fidl::encoding::Depth,
2436 ) -> fidl::Result<()> {
2437 encoder.debug_check_bounds::<Self>(offset);
2438 encoder.write_num(self.into_primitive(), offset);
2439 Ok(())
2440 }
2441 }
2442
2443 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2444 for ObserverWatchPlugStateError
2445 {
2446 #[inline(always)]
2447 fn new_empty() -> Self {
2448 Self::unknown()
2449 }
2450
2451 #[inline]
2452 unsafe fn decode(
2453 &mut self,
2454 decoder: &mut fidl::encoding::Decoder<'_, D>,
2455 offset: usize,
2456 _depth: fidl::encoding::Depth,
2457 ) -> fidl::Result<()> {
2458 decoder.debug_check_bounds::<Self>(offset);
2459 let prim = decoder.read_num::<u32>(offset);
2460
2461 *self = Self::from_primitive_allow_unknown(prim);
2462 Ok(())
2463 }
2464 }
2465 unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2466 type Owned = Self;
2467
2468 #[inline(always)]
2469 fn inline_align(_context: fidl::encoding::Context) -> usize {
2470 std::mem::align_of::<u32>()
2471 }
2472
2473 #[inline(always)]
2474 fn inline_size(_context: fidl::encoding::Context) -> usize {
2475 std::mem::size_of::<u32>()
2476 }
2477
2478 #[inline(always)]
2479 fn encode_is_copy() -> bool {
2480 false
2481 }
2482
2483 #[inline(always)]
2484 fn decode_is_copy() -> bool {
2485 false
2486 }
2487 }
2488
2489 impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2490 type Borrowed<'a> = Self;
2491 #[inline(always)]
2492 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2493 *value
2494 }
2495 }
2496
2497 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2498 for PlugDetectCapabilities
2499 {
2500 #[inline]
2501 unsafe fn encode(
2502 self,
2503 encoder: &mut fidl::encoding::Encoder<'_, D>,
2504 offset: usize,
2505 _depth: fidl::encoding::Depth,
2506 ) -> fidl::Result<()> {
2507 encoder.debug_check_bounds::<Self>(offset);
2508 encoder.write_num(self.into_primitive(), offset);
2509 Ok(())
2510 }
2511 }
2512
2513 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2514 for PlugDetectCapabilities
2515 {
2516 #[inline(always)]
2517 fn new_empty() -> Self {
2518 Self::unknown()
2519 }
2520
2521 #[inline]
2522 unsafe fn decode(
2523 &mut self,
2524 decoder: &mut fidl::encoding::Decoder<'_, D>,
2525 offset: usize,
2526 _depth: fidl::encoding::Depth,
2527 ) -> fidl::Result<()> {
2528 decoder.debug_check_bounds::<Self>(offset);
2529 let prim = decoder.read_num::<u32>(offset);
2530
2531 *self = Self::from_primitive_allow_unknown(prim);
2532 Ok(())
2533 }
2534 }
2535 unsafe impl fidl::encoding::TypeMarker for PlugState {
2536 type Owned = Self;
2537
2538 #[inline(always)]
2539 fn inline_align(_context: fidl::encoding::Context) -> usize {
2540 std::mem::align_of::<u32>()
2541 }
2542
2543 #[inline(always)]
2544 fn inline_size(_context: fidl::encoding::Context) -> usize {
2545 std::mem::size_of::<u32>()
2546 }
2547
2548 #[inline(always)]
2549 fn encode_is_copy() -> bool {
2550 false
2551 }
2552
2553 #[inline(always)]
2554 fn decode_is_copy() -> bool {
2555 false
2556 }
2557 }
2558
2559 impl fidl::encoding::ValueTypeMarker for PlugState {
2560 type Borrowed<'a> = Self;
2561 #[inline(always)]
2562 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2563 *value
2564 }
2565 }
2566
2567 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlugState {
2568 #[inline]
2569 unsafe fn encode(
2570 self,
2571 encoder: &mut fidl::encoding::Encoder<'_, D>,
2572 offset: usize,
2573 _depth: fidl::encoding::Depth,
2574 ) -> fidl::Result<()> {
2575 encoder.debug_check_bounds::<Self>(offset);
2576 encoder.write_num(self.into_primitive(), offset);
2577 Ok(())
2578 }
2579 }
2580
2581 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
2582 #[inline(always)]
2583 fn new_empty() -> Self {
2584 Self::unknown()
2585 }
2586
2587 #[inline]
2588 unsafe fn decode(
2589 &mut self,
2590 decoder: &mut fidl::encoding::Decoder<'_, D>,
2591 offset: usize,
2592 _depth: fidl::encoding::Depth,
2593 ) -> fidl::Result<()> {
2594 decoder.debug_check_bounds::<Self>(offset);
2595 let prim = decoder.read_num::<u32>(offset);
2596
2597 *self = Self::from_primitive_allow_unknown(prim);
2598 Ok(())
2599 }
2600 }
2601 unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceError {
2602 type Owned = Self;
2603
2604 #[inline(always)]
2605 fn inline_align(_context: fidl::encoding::Context) -> usize {
2606 std::mem::align_of::<u32>()
2607 }
2608
2609 #[inline(always)]
2610 fn inline_size(_context: fidl::encoding::Context) -> usize {
2611 std::mem::size_of::<u32>()
2612 }
2613
2614 #[inline(always)]
2615 fn encode_is_copy() -> bool {
2616 false
2617 }
2618
2619 #[inline(always)]
2620 fn decode_is_copy() -> bool {
2621 false
2622 }
2623 }
2624
2625 impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceError {
2626 type Borrowed<'a> = Self;
2627 #[inline(always)]
2628 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2629 *value
2630 }
2631 }
2632
2633 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2634 for ProviderAddDeviceError
2635 {
2636 #[inline]
2637 unsafe fn encode(
2638 self,
2639 encoder: &mut fidl::encoding::Encoder<'_, D>,
2640 offset: usize,
2641 _depth: fidl::encoding::Depth,
2642 ) -> fidl::Result<()> {
2643 encoder.debug_check_bounds::<Self>(offset);
2644 encoder.write_num(self.into_primitive(), offset);
2645 Ok(())
2646 }
2647 }
2648
2649 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2650 for ProviderAddDeviceError
2651 {
2652 #[inline(always)]
2653 fn new_empty() -> Self {
2654 Self::unknown()
2655 }
2656
2657 #[inline]
2658 unsafe fn decode(
2659 &mut self,
2660 decoder: &mut fidl::encoding::Decoder<'_, D>,
2661 offset: usize,
2662 _depth: fidl::encoding::Depth,
2663 ) -> fidl::Result<()> {
2664 decoder.debug_check_bounds::<Self>(offset);
2665 let prim = decoder.read_num::<u32>(offset);
2666
2667 *self = Self::from_primitive_allow_unknown(prim);
2668 Ok(())
2669 }
2670 }
2671 unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverError {
2672 type Owned = Self;
2673
2674 #[inline(always)]
2675 fn inline_align(_context: fidl::encoding::Context) -> usize {
2676 std::mem::align_of::<u32>()
2677 }
2678
2679 #[inline(always)]
2680 fn inline_size(_context: fidl::encoding::Context) -> usize {
2681 std::mem::size_of::<u32>()
2682 }
2683
2684 #[inline(always)]
2685 fn encode_is_copy() -> bool {
2686 false
2687 }
2688
2689 #[inline(always)]
2690 fn decode_is_copy() -> bool {
2691 false
2692 }
2693 }
2694
2695 impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverError {
2696 type Borrowed<'a> = Self;
2697 #[inline(always)]
2698 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2699 *value
2700 }
2701 }
2702
2703 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2704 for RegistryCreateObserverError
2705 {
2706 #[inline]
2707 unsafe fn encode(
2708 self,
2709 encoder: &mut fidl::encoding::Encoder<'_, D>,
2710 offset: usize,
2711 _depth: fidl::encoding::Depth,
2712 ) -> fidl::Result<()> {
2713 encoder.debug_check_bounds::<Self>(offset);
2714 encoder.write_num(self.into_primitive(), offset);
2715 Ok(())
2716 }
2717 }
2718
2719 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2720 for RegistryCreateObserverError
2721 {
2722 #[inline(always)]
2723 fn new_empty() -> Self {
2724 Self::unknown()
2725 }
2726
2727 #[inline]
2728 unsafe fn decode(
2729 &mut self,
2730 decoder: &mut fidl::encoding::Decoder<'_, D>,
2731 offset: usize,
2732 _depth: fidl::encoding::Depth,
2733 ) -> fidl::Result<()> {
2734 decoder.debug_check_bounds::<Self>(offset);
2735 let prim = decoder.read_num::<u32>(offset);
2736
2737 *self = Self::from_primitive_allow_unknown(prim);
2738 Ok(())
2739 }
2740 }
2741 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedError {
2742 type Owned = Self;
2743
2744 #[inline(always)]
2745 fn inline_align(_context: fidl::encoding::Context) -> usize {
2746 std::mem::align_of::<u32>()
2747 }
2748
2749 #[inline(always)]
2750 fn inline_size(_context: fidl::encoding::Context) -> usize {
2751 std::mem::size_of::<u32>()
2752 }
2753
2754 #[inline(always)]
2755 fn encode_is_copy() -> bool {
2756 false
2757 }
2758
2759 #[inline(always)]
2760 fn decode_is_copy() -> bool {
2761 false
2762 }
2763 }
2764
2765 impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedError {
2766 type Borrowed<'a> = Self;
2767 #[inline(always)]
2768 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2769 *value
2770 }
2771 }
2772
2773 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2774 for RegistryWatchDeviceRemovedError
2775 {
2776 #[inline]
2777 unsafe fn encode(
2778 self,
2779 encoder: &mut fidl::encoding::Encoder<'_, D>,
2780 offset: usize,
2781 _depth: fidl::encoding::Depth,
2782 ) -> fidl::Result<()> {
2783 encoder.debug_check_bounds::<Self>(offset);
2784 encoder.write_num(self.into_primitive(), offset);
2785 Ok(())
2786 }
2787 }
2788
2789 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2790 for RegistryWatchDeviceRemovedError
2791 {
2792 #[inline(always)]
2793 fn new_empty() -> Self {
2794 Self::unknown()
2795 }
2796
2797 #[inline]
2798 unsafe fn decode(
2799 &mut self,
2800 decoder: &mut fidl::encoding::Decoder<'_, D>,
2801 offset: usize,
2802 _depth: fidl::encoding::Depth,
2803 ) -> fidl::Result<()> {
2804 decoder.debug_check_bounds::<Self>(offset);
2805 let prim = decoder.read_num::<u32>(offset);
2806
2807 *self = Self::from_primitive_allow_unknown(prim);
2808 Ok(())
2809 }
2810 }
2811 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedError {
2812 type Owned = Self;
2813
2814 #[inline(always)]
2815 fn inline_align(_context: fidl::encoding::Context) -> usize {
2816 std::mem::align_of::<u32>()
2817 }
2818
2819 #[inline(always)]
2820 fn inline_size(_context: fidl::encoding::Context) -> usize {
2821 std::mem::size_of::<u32>()
2822 }
2823
2824 #[inline(always)]
2825 fn encode_is_copy() -> bool {
2826 false
2827 }
2828
2829 #[inline(always)]
2830 fn decode_is_copy() -> bool {
2831 false
2832 }
2833 }
2834
2835 impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedError {
2836 type Borrowed<'a> = Self;
2837 #[inline(always)]
2838 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2839 *value
2840 }
2841 }
2842
2843 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2844 for RegistryWatchDevicesAddedError
2845 {
2846 #[inline]
2847 unsafe fn encode(
2848 self,
2849 encoder: &mut fidl::encoding::Encoder<'_, D>,
2850 offset: usize,
2851 _depth: fidl::encoding::Depth,
2852 ) -> fidl::Result<()> {
2853 encoder.debug_check_bounds::<Self>(offset);
2854 encoder.write_num(self.into_primitive(), offset);
2855 Ok(())
2856 }
2857 }
2858
2859 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2860 for RegistryWatchDevicesAddedError
2861 {
2862 #[inline(always)]
2863 fn new_empty() -> Self {
2864 Self::unknown()
2865 }
2866
2867 #[inline]
2868 unsafe fn decode(
2869 &mut self,
2870 decoder: &mut fidl::encoding::Decoder<'_, D>,
2871 offset: usize,
2872 _depth: fidl::encoding::Depth,
2873 ) -> fidl::Result<()> {
2874 decoder.debug_check_bounds::<Self>(offset);
2875 let prim = decoder.read_num::<u32>(offset);
2876
2877 *self = Self::from_primitive_allow_unknown(prim);
2878 Ok(())
2879 }
2880 }
2881 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsError {
2882 type Owned = Self;
2883
2884 #[inline(always)]
2885 fn inline_align(_context: fidl::encoding::Context) -> usize {
2886 std::mem::align_of::<u32>()
2887 }
2888
2889 #[inline(always)]
2890 fn inline_size(_context: fidl::encoding::Context) -> usize {
2891 std::mem::size_of::<u32>()
2892 }
2893
2894 #[inline(always)]
2895 fn encode_is_copy() -> bool {
2896 false
2897 }
2898
2899 #[inline(always)]
2900 fn decode_is_copy() -> bool {
2901 false
2902 }
2903 }
2904
2905 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsError {
2906 type Borrowed<'a> = Self;
2907 #[inline(always)]
2908 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2909 *value
2910 }
2911 }
2912
2913 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2914 for RingBufferSetActiveChannelsError
2915 {
2916 #[inline]
2917 unsafe fn encode(
2918 self,
2919 encoder: &mut fidl::encoding::Encoder<'_, D>,
2920 offset: usize,
2921 _depth: fidl::encoding::Depth,
2922 ) -> fidl::Result<()> {
2923 encoder.debug_check_bounds::<Self>(offset);
2924 encoder.write_num(self.into_primitive(), offset);
2925 Ok(())
2926 }
2927 }
2928
2929 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2930 for RingBufferSetActiveChannelsError
2931 {
2932 #[inline(always)]
2933 fn new_empty() -> Self {
2934 Self::unknown()
2935 }
2936
2937 #[inline]
2938 unsafe fn decode(
2939 &mut self,
2940 decoder: &mut fidl::encoding::Decoder<'_, D>,
2941 offset: usize,
2942 _depth: fidl::encoding::Depth,
2943 ) -> fidl::Result<()> {
2944 decoder.debug_check_bounds::<Self>(offset);
2945 let prim = decoder.read_num::<u32>(offset);
2946
2947 *self = Self::from_primitive_allow_unknown(prim);
2948 Ok(())
2949 }
2950 }
2951 unsafe impl fidl::encoding::TypeMarker for RingBufferStartError {
2952 type Owned = Self;
2953
2954 #[inline(always)]
2955 fn inline_align(_context: fidl::encoding::Context) -> usize {
2956 std::mem::align_of::<u32>()
2957 }
2958
2959 #[inline(always)]
2960 fn inline_size(_context: fidl::encoding::Context) -> usize {
2961 std::mem::size_of::<u32>()
2962 }
2963
2964 #[inline(always)]
2965 fn encode_is_copy() -> bool {
2966 false
2967 }
2968
2969 #[inline(always)]
2970 fn decode_is_copy() -> bool {
2971 false
2972 }
2973 }
2974
2975 impl fidl::encoding::ValueTypeMarker for RingBufferStartError {
2976 type Borrowed<'a> = Self;
2977 #[inline(always)]
2978 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2979 *value
2980 }
2981 }
2982
2983 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2984 for RingBufferStartError
2985 {
2986 #[inline]
2987 unsafe fn encode(
2988 self,
2989 encoder: &mut fidl::encoding::Encoder<'_, D>,
2990 offset: usize,
2991 _depth: fidl::encoding::Depth,
2992 ) -> fidl::Result<()> {
2993 encoder.debug_check_bounds::<Self>(offset);
2994 encoder.write_num(self.into_primitive(), offset);
2995 Ok(())
2996 }
2997 }
2998
2999 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStartError {
3000 #[inline(always)]
3001 fn new_empty() -> Self {
3002 Self::unknown()
3003 }
3004
3005 #[inline]
3006 unsafe fn decode(
3007 &mut self,
3008 decoder: &mut fidl::encoding::Decoder<'_, D>,
3009 offset: usize,
3010 _depth: fidl::encoding::Depth,
3011 ) -> fidl::Result<()> {
3012 decoder.debug_check_bounds::<Self>(offset);
3013 let prim = decoder.read_num::<u32>(offset);
3014
3015 *self = Self::from_primitive_allow_unknown(prim);
3016 Ok(())
3017 }
3018 }
3019 unsafe impl fidl::encoding::TypeMarker for RingBufferStopError {
3020 type Owned = Self;
3021
3022 #[inline(always)]
3023 fn inline_align(_context: fidl::encoding::Context) -> usize {
3024 std::mem::align_of::<u32>()
3025 }
3026
3027 #[inline(always)]
3028 fn inline_size(_context: fidl::encoding::Context) -> usize {
3029 std::mem::size_of::<u32>()
3030 }
3031
3032 #[inline(always)]
3033 fn encode_is_copy() -> bool {
3034 false
3035 }
3036
3037 #[inline(always)]
3038 fn decode_is_copy() -> bool {
3039 false
3040 }
3041 }
3042
3043 impl fidl::encoding::ValueTypeMarker for RingBufferStopError {
3044 type Borrowed<'a> = Self;
3045 #[inline(always)]
3046 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3047 *value
3048 }
3049 }
3050
3051 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3052 for RingBufferStopError
3053 {
3054 #[inline]
3055 unsafe fn encode(
3056 self,
3057 encoder: &mut fidl::encoding::Encoder<'_, D>,
3058 offset: usize,
3059 _depth: fidl::encoding::Depth,
3060 ) -> fidl::Result<()> {
3061 encoder.debug_check_bounds::<Self>(offset);
3062 encoder.write_num(self.into_primitive(), offset);
3063 Ok(())
3064 }
3065 }
3066
3067 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopError {
3068 #[inline(always)]
3069 fn new_empty() -> Self {
3070 Self::unknown()
3071 }
3072
3073 #[inline]
3074 unsafe fn decode(
3075 &mut self,
3076 decoder: &mut fidl::encoding::Decoder<'_, D>,
3077 offset: usize,
3078 _depth: fidl::encoding::Depth,
3079 ) -> fidl::Result<()> {
3080 decoder.debug_check_bounds::<Self>(offset);
3081 let prim = decoder.read_num::<u32>(offset);
3082
3083 *self = Self::from_primitive_allow_unknown(prim);
3084 Ok(())
3085 }
3086 }
3087 unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoError {
3088 type Owned = Self;
3089
3090 #[inline(always)]
3091 fn inline_align(_context: fidl::encoding::Context) -> usize {
3092 std::mem::align_of::<u32>()
3093 }
3094
3095 #[inline(always)]
3096 fn inline_size(_context: fidl::encoding::Context) -> usize {
3097 std::mem::size_of::<u32>()
3098 }
3099
3100 #[inline(always)]
3101 fn encode_is_copy() -> bool {
3102 false
3103 }
3104
3105 #[inline(always)]
3106 fn decode_is_copy() -> bool {
3107 false
3108 }
3109 }
3110
3111 impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoError {
3112 type Borrowed<'a> = Self;
3113 #[inline(always)]
3114 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3115 *value
3116 }
3117 }
3118
3119 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3120 for RingBufferWatchDelayInfoError
3121 {
3122 #[inline]
3123 unsafe fn encode(
3124 self,
3125 encoder: &mut fidl::encoding::Encoder<'_, D>,
3126 offset: usize,
3127 _depth: fidl::encoding::Depth,
3128 ) -> fidl::Result<()> {
3129 encoder.debug_check_bounds::<Self>(offset);
3130 encoder.write_num(self.into_primitive(), offset);
3131 Ok(())
3132 }
3133 }
3134
3135 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3136 for RingBufferWatchDelayInfoError
3137 {
3138 #[inline(always)]
3139 fn new_empty() -> Self {
3140 Self::unknown()
3141 }
3142
3143 #[inline]
3144 unsafe fn decode(
3145 &mut self,
3146 decoder: &mut fidl::encoding::Decoder<'_, D>,
3147 offset: usize,
3148 _depth: fidl::encoding::Depth,
3149 ) -> fidl::Result<()> {
3150 decoder.debug_check_bounds::<Self>(offset);
3151 let prim = decoder.read_num::<u32>(offset);
3152
3153 *self = Self::from_primitive_allow_unknown(prim);
3154 Ok(())
3155 }
3156 }
3157
3158 impl ChannelAttributes {
3159 #[inline(always)]
3160 fn max_ordinal_present(&self) -> u64 {
3161 if let Some(_) = self.max_frequency {
3162 return 2;
3163 }
3164 if let Some(_) = self.min_frequency {
3165 return 1;
3166 }
3167 0
3168 }
3169 }
3170
3171 impl fidl::encoding::ValueTypeMarker for ChannelAttributes {
3172 type Borrowed<'a> = &'a Self;
3173 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3174 value
3175 }
3176 }
3177
3178 unsafe impl fidl::encoding::TypeMarker for ChannelAttributes {
3179 type Owned = Self;
3180
3181 #[inline(always)]
3182 fn inline_align(_context: fidl::encoding::Context) -> usize {
3183 8
3184 }
3185
3186 #[inline(always)]
3187 fn inline_size(_context: fidl::encoding::Context) -> usize {
3188 16
3189 }
3190 }
3191
3192 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelAttributes, D>
3193 for &ChannelAttributes
3194 {
3195 unsafe fn encode(
3196 self,
3197 encoder: &mut fidl::encoding::Encoder<'_, D>,
3198 offset: usize,
3199 mut depth: fidl::encoding::Depth,
3200 ) -> fidl::Result<()> {
3201 encoder.debug_check_bounds::<ChannelAttributes>(offset);
3202 let max_ordinal: u64 = self.max_ordinal_present();
3204 encoder.write_num(max_ordinal, offset);
3205 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3206 if max_ordinal == 0 {
3208 return Ok(());
3209 }
3210 depth.increment()?;
3211 let envelope_size = 8;
3212 let bytes_len = max_ordinal as usize * envelope_size;
3213 #[allow(unused_variables)]
3214 let offset = encoder.out_of_line_offset(bytes_len);
3215 let mut _prev_end_offset: usize = 0;
3216 if 1 > max_ordinal {
3217 return Ok(());
3218 }
3219
3220 let cur_offset: usize = (1 - 1) * envelope_size;
3223
3224 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3226
3227 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3232 self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3233 encoder,
3234 offset + cur_offset,
3235 depth,
3236 )?;
3237
3238 _prev_end_offset = cur_offset + envelope_size;
3239 if 2 > max_ordinal {
3240 return Ok(());
3241 }
3242
3243 let cur_offset: usize = (2 - 1) * envelope_size;
3246
3247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3255 self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3256 encoder,
3257 offset + cur_offset,
3258 depth,
3259 )?;
3260
3261 _prev_end_offset = cur_offset + envelope_size;
3262
3263 Ok(())
3264 }
3265 }
3266
3267 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelAttributes {
3268 #[inline(always)]
3269 fn new_empty() -> Self {
3270 Self::default()
3271 }
3272
3273 unsafe fn decode(
3274 &mut self,
3275 decoder: &mut fidl::encoding::Decoder<'_, D>,
3276 offset: usize,
3277 mut depth: fidl::encoding::Depth,
3278 ) -> fidl::Result<()> {
3279 decoder.debug_check_bounds::<Self>(offset);
3280 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3281 None => return Err(fidl::Error::NotNullable),
3282 Some(len) => len,
3283 };
3284 if len == 0 {
3286 return Ok(());
3287 };
3288 depth.increment()?;
3289 let envelope_size = 8;
3290 let bytes_len = len * envelope_size;
3291 let offset = decoder.out_of_line_offset(bytes_len)?;
3292 let mut _next_ordinal_to_read = 0;
3294 let mut next_offset = offset;
3295 let end_offset = offset + bytes_len;
3296 _next_ordinal_to_read += 1;
3297 if next_offset >= end_offset {
3298 return Ok(());
3299 }
3300
3301 while _next_ordinal_to_read < 1 {
3303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3304 _next_ordinal_to_read += 1;
3305 next_offset += envelope_size;
3306 }
3307
3308 let next_out_of_line = decoder.next_out_of_line();
3309 let handles_before = decoder.remaining_handles();
3310 if let Some((inlined, num_bytes, num_handles)) =
3311 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3312 {
3313 let member_inline_size =
3314 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3315 if inlined != (member_inline_size <= 4) {
3316 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3317 }
3318 let inner_offset;
3319 let mut inner_depth = depth.clone();
3320 if inlined {
3321 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3322 inner_offset = next_offset;
3323 } else {
3324 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3325 inner_depth.increment()?;
3326 }
3327 let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3328 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3329 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3330 {
3331 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3332 }
3333 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3334 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3335 }
3336 }
3337
3338 next_offset += envelope_size;
3339 _next_ordinal_to_read += 1;
3340 if next_offset >= end_offset {
3341 return Ok(());
3342 }
3343
3344 while _next_ordinal_to_read < 2 {
3346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3347 _next_ordinal_to_read += 1;
3348 next_offset += envelope_size;
3349 }
3350
3351 let next_out_of_line = decoder.next_out_of_line();
3352 let handles_before = decoder.remaining_handles();
3353 if let Some((inlined, num_bytes, num_handles)) =
3354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3355 {
3356 let member_inline_size =
3357 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3358 if inlined != (member_inline_size <= 4) {
3359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3360 }
3361 let inner_offset;
3362 let mut inner_depth = depth.clone();
3363 if inlined {
3364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3365 inner_offset = next_offset;
3366 } else {
3367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3368 inner_depth.increment()?;
3369 }
3370 let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3371 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3372 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3373 {
3374 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3375 }
3376 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3377 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3378 }
3379 }
3380
3381 next_offset += envelope_size;
3382
3383 while next_offset < end_offset {
3385 _next_ordinal_to_read += 1;
3386 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3387 next_offset += envelope_size;
3388 }
3389
3390 Ok(())
3391 }
3392 }
3393
3394 impl ChannelSet {
3395 #[inline(always)]
3396 fn max_ordinal_present(&self) -> u64 {
3397 if let Some(_) = self.attributes {
3398 return 1;
3399 }
3400 0
3401 }
3402 }
3403
3404 impl fidl::encoding::ValueTypeMarker for ChannelSet {
3405 type Borrowed<'a> = &'a Self;
3406 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3407 value
3408 }
3409 }
3410
3411 unsafe impl fidl::encoding::TypeMarker for ChannelSet {
3412 type Owned = Self;
3413
3414 #[inline(always)]
3415 fn inline_align(_context: fidl::encoding::Context) -> usize {
3416 8
3417 }
3418
3419 #[inline(always)]
3420 fn inline_size(_context: fidl::encoding::Context) -> usize {
3421 16
3422 }
3423 }
3424
3425 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelSet, D>
3426 for &ChannelSet
3427 {
3428 unsafe fn encode(
3429 self,
3430 encoder: &mut fidl::encoding::Encoder<'_, D>,
3431 offset: usize,
3432 mut depth: fidl::encoding::Depth,
3433 ) -> fidl::Result<()> {
3434 encoder.debug_check_bounds::<ChannelSet>(offset);
3435 let max_ordinal: u64 = self.max_ordinal_present();
3437 encoder.write_num(max_ordinal, offset);
3438 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3439 if max_ordinal == 0 {
3441 return Ok(());
3442 }
3443 depth.increment()?;
3444 let envelope_size = 8;
3445 let bytes_len = max_ordinal as usize * envelope_size;
3446 #[allow(unused_variables)]
3447 let offset = encoder.out_of_line_offset(bytes_len);
3448 let mut _prev_end_offset: usize = 0;
3449 if 1 > max_ordinal {
3450 return Ok(());
3451 }
3452
3453 let cur_offset: usize = (1 - 1) * envelope_size;
3456
3457 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3459
3460 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelAttributes, 64>, D>(
3465 self.attributes.as_ref().map(<fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3466 encoder, offset + cur_offset, depth
3467 )?;
3468
3469 _prev_end_offset = cur_offset + envelope_size;
3470
3471 Ok(())
3472 }
3473 }
3474
3475 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelSet {
3476 #[inline(always)]
3477 fn new_empty() -> Self {
3478 Self::default()
3479 }
3480
3481 unsafe fn decode(
3482 &mut self,
3483 decoder: &mut fidl::encoding::Decoder<'_, D>,
3484 offset: usize,
3485 mut depth: fidl::encoding::Depth,
3486 ) -> fidl::Result<()> {
3487 decoder.debug_check_bounds::<Self>(offset);
3488 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3489 None => return Err(fidl::Error::NotNullable),
3490 Some(len) => len,
3491 };
3492 if len == 0 {
3494 return Ok(());
3495 };
3496 depth.increment()?;
3497 let envelope_size = 8;
3498 let bytes_len = len * envelope_size;
3499 let offset = decoder.out_of_line_offset(bytes_len)?;
3500 let mut _next_ordinal_to_read = 0;
3502 let mut next_offset = offset;
3503 let end_offset = offset + bytes_len;
3504 _next_ordinal_to_read += 1;
3505 if next_offset >= end_offset {
3506 return Ok(());
3507 }
3508
3509 while _next_ordinal_to_read < 1 {
3511 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3512 _next_ordinal_to_read += 1;
3513 next_offset += envelope_size;
3514 }
3515
3516 let next_out_of_line = decoder.next_out_of_line();
3517 let handles_before = decoder.remaining_handles();
3518 if let Some((inlined, num_bytes, num_handles)) =
3519 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3520 {
3521 let member_inline_size = <fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3522 if inlined != (member_inline_size <= 4) {
3523 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3524 }
3525 let inner_offset;
3526 let mut inner_depth = depth.clone();
3527 if inlined {
3528 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3529 inner_offset = next_offset;
3530 } else {
3531 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3532 inner_depth.increment()?;
3533 }
3534 let val_ref = self.attributes.get_or_insert_with(
3535 || fidl::new_empty!(fidl::encoding::Vector<ChannelAttributes, 64>, D),
3536 );
3537 fidl::decode!(fidl::encoding::Vector<ChannelAttributes, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3538 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3539 {
3540 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3541 }
3542 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3543 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3544 }
3545 }
3546
3547 next_offset += envelope_size;
3548
3549 while next_offset < end_offset {
3551 _next_ordinal_to_read += 1;
3552 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3553 next_offset += envelope_size;
3554 }
3555
3556 Ok(())
3557 }
3558 }
3559
3560 impl ControlCreatorCreateResponse {
3561 #[inline(always)]
3562 fn max_ordinal_present(&self) -> u64 {
3563 0
3564 }
3565 }
3566
3567 impl fidl::encoding::ValueTypeMarker for ControlCreatorCreateResponse {
3568 type Borrowed<'a> = &'a Self;
3569 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3570 value
3571 }
3572 }
3573
3574 unsafe impl fidl::encoding::TypeMarker for ControlCreatorCreateResponse {
3575 type Owned = Self;
3576
3577 #[inline(always)]
3578 fn inline_align(_context: fidl::encoding::Context) -> usize {
3579 8
3580 }
3581
3582 #[inline(always)]
3583 fn inline_size(_context: fidl::encoding::Context) -> usize {
3584 16
3585 }
3586 }
3587
3588 unsafe impl<D: fidl::encoding::ResourceDialect>
3589 fidl::encoding::Encode<ControlCreatorCreateResponse, D> for &ControlCreatorCreateResponse
3590 {
3591 unsafe fn encode(
3592 self,
3593 encoder: &mut fidl::encoding::Encoder<'_, D>,
3594 offset: usize,
3595 mut depth: fidl::encoding::Depth,
3596 ) -> fidl::Result<()> {
3597 encoder.debug_check_bounds::<ControlCreatorCreateResponse>(offset);
3598 let max_ordinal: u64 = self.max_ordinal_present();
3600 encoder.write_num(max_ordinal, offset);
3601 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3602 if max_ordinal == 0 {
3604 return Ok(());
3605 }
3606 depth.increment()?;
3607 let envelope_size = 8;
3608 let bytes_len = max_ordinal as usize * envelope_size;
3609 #[allow(unused_variables)]
3610 let offset = encoder.out_of_line_offset(bytes_len);
3611 let mut _prev_end_offset: usize = 0;
3612
3613 Ok(())
3614 }
3615 }
3616
3617 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3618 for ControlCreatorCreateResponse
3619 {
3620 #[inline(always)]
3621 fn new_empty() -> Self {
3622 Self::default()
3623 }
3624
3625 unsafe fn decode(
3626 &mut self,
3627 decoder: &mut fidl::encoding::Decoder<'_, D>,
3628 offset: usize,
3629 mut depth: fidl::encoding::Depth,
3630 ) -> fidl::Result<()> {
3631 decoder.debug_check_bounds::<Self>(offset);
3632 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3633 None => return Err(fidl::Error::NotNullable),
3634 Some(len) => len,
3635 };
3636 if len == 0 {
3638 return Ok(());
3639 };
3640 depth.increment()?;
3641 let envelope_size = 8;
3642 let bytes_len = len * envelope_size;
3643 let offset = decoder.out_of_line_offset(bytes_len)?;
3644 let mut _next_ordinal_to_read = 0;
3646 let mut next_offset = offset;
3647 let end_offset = offset + bytes_len;
3648
3649 while next_offset < end_offset {
3651 _next_ordinal_to_read += 1;
3652 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3653 next_offset += envelope_size;
3654 }
3655
3656 Ok(())
3657 }
3658 }
3659
3660 impl ControlSetDaiFormatRequest {
3661 #[inline(always)]
3662 fn max_ordinal_present(&self) -> u64 {
3663 if let Some(_) = self.dai_format {
3664 return 2;
3665 }
3666 if let Some(_) = self.element_id {
3667 return 1;
3668 }
3669 0
3670 }
3671 }
3672
3673 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatRequest {
3674 type Borrowed<'a> = &'a Self;
3675 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3676 value
3677 }
3678 }
3679
3680 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatRequest {
3681 type Owned = Self;
3682
3683 #[inline(always)]
3684 fn inline_align(_context: fidl::encoding::Context) -> usize {
3685 8
3686 }
3687
3688 #[inline(always)]
3689 fn inline_size(_context: fidl::encoding::Context) -> usize {
3690 16
3691 }
3692 }
3693
3694 unsafe impl<D: fidl::encoding::ResourceDialect>
3695 fidl::encoding::Encode<ControlSetDaiFormatRequest, D> for &ControlSetDaiFormatRequest
3696 {
3697 unsafe fn encode(
3698 self,
3699 encoder: &mut fidl::encoding::Encoder<'_, D>,
3700 offset: usize,
3701 mut depth: fidl::encoding::Depth,
3702 ) -> fidl::Result<()> {
3703 encoder.debug_check_bounds::<ControlSetDaiFormatRequest>(offset);
3704 let max_ordinal: u64 = self.max_ordinal_present();
3706 encoder.write_num(max_ordinal, offset);
3707 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3708 if max_ordinal == 0 {
3710 return Ok(());
3711 }
3712 depth.increment()?;
3713 let envelope_size = 8;
3714 let bytes_len = max_ordinal as usize * envelope_size;
3715 #[allow(unused_variables)]
3716 let offset = encoder.out_of_line_offset(bytes_len);
3717 let mut _prev_end_offset: usize = 0;
3718 if 1 > max_ordinal {
3719 return Ok(());
3720 }
3721
3722 let cur_offset: usize = (1 - 1) * envelope_size;
3725
3726 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3728
3729 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3734 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3735 encoder,
3736 offset + cur_offset,
3737 depth,
3738 )?;
3739
3740 _prev_end_offset = cur_offset + envelope_size;
3741 if 2 > max_ordinal {
3742 return Ok(());
3743 }
3744
3745 let cur_offset: usize = (2 - 1) * envelope_size;
3748
3749 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3751
3752 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::DaiFormat, D>(
3757 self.dai_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::ValueTypeMarker>::borrow),
3758 encoder, offset + cur_offset, depth
3759 )?;
3760
3761 _prev_end_offset = cur_offset + envelope_size;
3762
3763 Ok(())
3764 }
3765 }
3766
3767 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3768 for ControlSetDaiFormatRequest
3769 {
3770 #[inline(always)]
3771 fn new_empty() -> Self {
3772 Self::default()
3773 }
3774
3775 unsafe fn decode(
3776 &mut self,
3777 decoder: &mut fidl::encoding::Decoder<'_, D>,
3778 offset: usize,
3779 mut depth: fidl::encoding::Depth,
3780 ) -> fidl::Result<()> {
3781 decoder.debug_check_bounds::<Self>(offset);
3782 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3783 None => return Err(fidl::Error::NotNullable),
3784 Some(len) => len,
3785 };
3786 if len == 0 {
3788 return Ok(());
3789 };
3790 depth.increment()?;
3791 let envelope_size = 8;
3792 let bytes_len = len * envelope_size;
3793 let offset = decoder.out_of_line_offset(bytes_len)?;
3794 let mut _next_ordinal_to_read = 0;
3796 let mut next_offset = offset;
3797 let end_offset = offset + bytes_len;
3798 _next_ordinal_to_read += 1;
3799 if next_offset >= end_offset {
3800 return Ok(());
3801 }
3802
3803 while _next_ordinal_to_read < 1 {
3805 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3806 _next_ordinal_to_read += 1;
3807 next_offset += envelope_size;
3808 }
3809
3810 let next_out_of_line = decoder.next_out_of_line();
3811 let handles_before = decoder.remaining_handles();
3812 if let Some((inlined, num_bytes, num_handles)) =
3813 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3814 {
3815 let member_inline_size =
3816 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3817 if inlined != (member_inline_size <= 4) {
3818 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3819 }
3820 let inner_offset;
3821 let mut inner_depth = depth.clone();
3822 if inlined {
3823 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3824 inner_offset = next_offset;
3825 } else {
3826 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3827 inner_depth.increment()?;
3828 }
3829 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3830 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3831 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3832 {
3833 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3834 }
3835 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3836 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3837 }
3838 }
3839
3840 next_offset += envelope_size;
3841 _next_ordinal_to_read += 1;
3842 if next_offset >= end_offset {
3843 return Ok(());
3844 }
3845
3846 while _next_ordinal_to_read < 2 {
3848 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3849 _next_ordinal_to_read += 1;
3850 next_offset += envelope_size;
3851 }
3852
3853 let next_out_of_line = decoder.next_out_of_line();
3854 let handles_before = decoder.remaining_handles();
3855 if let Some((inlined, num_bytes, num_handles)) =
3856 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3857 {
3858 let member_inline_size = <fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3859 if inlined != (member_inline_size <= 4) {
3860 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3861 }
3862 let inner_offset;
3863 let mut inner_depth = depth.clone();
3864 if inlined {
3865 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3866 inner_offset = next_offset;
3867 } else {
3868 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3869 inner_depth.increment()?;
3870 }
3871 let val_ref = self.dai_format.get_or_insert_with(|| {
3872 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::DaiFormat, D)
3873 });
3874 fidl::decode!(
3875 fidl_fuchsia_hardware_audio__common::DaiFormat,
3876 D,
3877 val_ref,
3878 decoder,
3879 inner_offset,
3880 inner_depth
3881 )?;
3882 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3883 {
3884 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3885 }
3886 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3887 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3888 }
3889 }
3890
3891 next_offset += envelope_size;
3892
3893 while next_offset < end_offset {
3895 _next_ordinal_to_read += 1;
3896 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3897 next_offset += envelope_size;
3898 }
3899
3900 Ok(())
3901 }
3902 }
3903
3904 impl ControlCodecStartResponse {
3905 #[inline(always)]
3906 fn max_ordinal_present(&self) -> u64 {
3907 if let Some(_) = self.start_time {
3908 return 1;
3909 }
3910 0
3911 }
3912 }
3913
3914 impl fidl::encoding::ValueTypeMarker for ControlCodecStartResponse {
3915 type Borrowed<'a> = &'a Self;
3916 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3917 value
3918 }
3919 }
3920
3921 unsafe impl fidl::encoding::TypeMarker for ControlCodecStartResponse {
3922 type Owned = Self;
3923
3924 #[inline(always)]
3925 fn inline_align(_context: fidl::encoding::Context) -> usize {
3926 8
3927 }
3928
3929 #[inline(always)]
3930 fn inline_size(_context: fidl::encoding::Context) -> usize {
3931 16
3932 }
3933 }
3934
3935 unsafe impl<D: fidl::encoding::ResourceDialect>
3936 fidl::encoding::Encode<ControlCodecStartResponse, D> for &ControlCodecStartResponse
3937 {
3938 unsafe fn encode(
3939 self,
3940 encoder: &mut fidl::encoding::Encoder<'_, D>,
3941 offset: usize,
3942 mut depth: fidl::encoding::Depth,
3943 ) -> fidl::Result<()> {
3944 encoder.debug_check_bounds::<ControlCodecStartResponse>(offset);
3945 let max_ordinal: u64 = self.max_ordinal_present();
3947 encoder.write_num(max_ordinal, offset);
3948 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3949 if max_ordinal == 0 {
3951 return Ok(());
3952 }
3953 depth.increment()?;
3954 let envelope_size = 8;
3955 let bytes_len = max_ordinal as usize * envelope_size;
3956 #[allow(unused_variables)]
3957 let offset = encoder.out_of_line_offset(bytes_len);
3958 let mut _prev_end_offset: usize = 0;
3959 if 1 > max_ordinal {
3960 return Ok(());
3961 }
3962
3963 let cur_offset: usize = (1 - 1) * envelope_size;
3966
3967 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3969
3970 fidl::encoding::encode_in_envelope_optional::<i64, D>(
3975 self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3976 encoder,
3977 offset + cur_offset,
3978 depth,
3979 )?;
3980
3981 _prev_end_offset = cur_offset + envelope_size;
3982
3983 Ok(())
3984 }
3985 }
3986
3987 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3988 for ControlCodecStartResponse
3989 {
3990 #[inline(always)]
3991 fn new_empty() -> Self {
3992 Self::default()
3993 }
3994
3995 unsafe fn decode(
3996 &mut self,
3997 decoder: &mut fidl::encoding::Decoder<'_, D>,
3998 offset: usize,
3999 mut depth: fidl::encoding::Depth,
4000 ) -> fidl::Result<()> {
4001 decoder.debug_check_bounds::<Self>(offset);
4002 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4003 None => return Err(fidl::Error::NotNullable),
4004 Some(len) => len,
4005 };
4006 if len == 0 {
4008 return Ok(());
4009 };
4010 depth.increment()?;
4011 let envelope_size = 8;
4012 let bytes_len = len * envelope_size;
4013 let offset = decoder.out_of_line_offset(bytes_len)?;
4014 let mut _next_ordinal_to_read = 0;
4016 let mut next_offset = offset;
4017 let end_offset = offset + bytes_len;
4018 _next_ordinal_to_read += 1;
4019 if next_offset >= end_offset {
4020 return Ok(());
4021 }
4022
4023 while _next_ordinal_to_read < 1 {
4025 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4026 _next_ordinal_to_read += 1;
4027 next_offset += envelope_size;
4028 }
4029
4030 let next_out_of_line = decoder.next_out_of_line();
4031 let handles_before = decoder.remaining_handles();
4032 if let Some((inlined, num_bytes, num_handles)) =
4033 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4034 {
4035 let member_inline_size =
4036 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4037 if inlined != (member_inline_size <= 4) {
4038 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4039 }
4040 let inner_offset;
4041 let mut inner_depth = depth.clone();
4042 if inlined {
4043 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4044 inner_offset = next_offset;
4045 } else {
4046 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4047 inner_depth.increment()?;
4048 }
4049 let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4050 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4051 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4052 {
4053 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4054 }
4055 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4056 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4057 }
4058 }
4059
4060 next_offset += envelope_size;
4061
4062 while next_offset < end_offset {
4064 _next_ordinal_to_read += 1;
4065 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4066 next_offset += envelope_size;
4067 }
4068
4069 Ok(())
4070 }
4071 }
4072
4073 impl ControlCodecStopResponse {
4074 #[inline(always)]
4075 fn max_ordinal_present(&self) -> u64 {
4076 if let Some(_) = self.stop_time {
4077 return 1;
4078 }
4079 0
4080 }
4081 }
4082
4083 impl fidl::encoding::ValueTypeMarker for ControlCodecStopResponse {
4084 type Borrowed<'a> = &'a Self;
4085 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4086 value
4087 }
4088 }
4089
4090 unsafe impl fidl::encoding::TypeMarker for ControlCodecStopResponse {
4091 type Owned = Self;
4092
4093 #[inline(always)]
4094 fn inline_align(_context: fidl::encoding::Context) -> usize {
4095 8
4096 }
4097
4098 #[inline(always)]
4099 fn inline_size(_context: fidl::encoding::Context) -> usize {
4100 16
4101 }
4102 }
4103
4104 unsafe impl<D: fidl::encoding::ResourceDialect>
4105 fidl::encoding::Encode<ControlCodecStopResponse, D> for &ControlCodecStopResponse
4106 {
4107 unsafe fn encode(
4108 self,
4109 encoder: &mut fidl::encoding::Encoder<'_, D>,
4110 offset: usize,
4111 mut depth: fidl::encoding::Depth,
4112 ) -> fidl::Result<()> {
4113 encoder.debug_check_bounds::<ControlCodecStopResponse>(offset);
4114 let max_ordinal: u64 = self.max_ordinal_present();
4116 encoder.write_num(max_ordinal, offset);
4117 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4118 if max_ordinal == 0 {
4120 return Ok(());
4121 }
4122 depth.increment()?;
4123 let envelope_size = 8;
4124 let bytes_len = max_ordinal as usize * envelope_size;
4125 #[allow(unused_variables)]
4126 let offset = encoder.out_of_line_offset(bytes_len);
4127 let mut _prev_end_offset: usize = 0;
4128 if 1 > max_ordinal {
4129 return Ok(());
4130 }
4131
4132 let cur_offset: usize = (1 - 1) * envelope_size;
4135
4136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4138
4139 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4144 self.stop_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4145 encoder,
4146 offset + cur_offset,
4147 depth,
4148 )?;
4149
4150 _prev_end_offset = cur_offset + envelope_size;
4151
4152 Ok(())
4153 }
4154 }
4155
4156 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4157 for ControlCodecStopResponse
4158 {
4159 #[inline(always)]
4160 fn new_empty() -> Self {
4161 Self::default()
4162 }
4163
4164 unsafe fn decode(
4165 &mut self,
4166 decoder: &mut fidl::encoding::Decoder<'_, D>,
4167 offset: usize,
4168 mut depth: fidl::encoding::Depth,
4169 ) -> fidl::Result<()> {
4170 decoder.debug_check_bounds::<Self>(offset);
4171 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4172 None => return Err(fidl::Error::NotNullable),
4173 Some(len) => len,
4174 };
4175 if len == 0 {
4177 return Ok(());
4178 };
4179 depth.increment()?;
4180 let envelope_size = 8;
4181 let bytes_len = len * envelope_size;
4182 let offset = decoder.out_of_line_offset(bytes_len)?;
4183 let mut _next_ordinal_to_read = 0;
4185 let mut next_offset = offset;
4186 let end_offset = offset + bytes_len;
4187 _next_ordinal_to_read += 1;
4188 if next_offset >= end_offset {
4189 return Ok(());
4190 }
4191
4192 while _next_ordinal_to_read < 1 {
4194 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4195 _next_ordinal_to_read += 1;
4196 next_offset += envelope_size;
4197 }
4198
4199 let next_out_of_line = decoder.next_out_of_line();
4200 let handles_before = decoder.remaining_handles();
4201 if let Some((inlined, num_bytes, num_handles)) =
4202 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4203 {
4204 let member_inline_size =
4205 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4206 if inlined != (member_inline_size <= 4) {
4207 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4208 }
4209 let inner_offset;
4210 let mut inner_depth = depth.clone();
4211 if inlined {
4212 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4213 inner_offset = next_offset;
4214 } else {
4215 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4216 inner_depth.increment()?;
4217 }
4218 let val_ref = self.stop_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4219 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4220 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4221 {
4222 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4223 }
4224 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4225 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4226 }
4227 }
4228
4229 next_offset += envelope_size;
4230
4231 while next_offset < end_offset {
4233 _next_ordinal_to_read += 1;
4234 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4235 next_offset += envelope_size;
4236 }
4237
4238 Ok(())
4239 }
4240 }
4241
4242 impl ControlResetResponse {
4243 #[inline(always)]
4244 fn max_ordinal_present(&self) -> u64 {
4245 0
4246 }
4247 }
4248
4249 impl fidl::encoding::ValueTypeMarker for ControlResetResponse {
4250 type Borrowed<'a> = &'a Self;
4251 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4252 value
4253 }
4254 }
4255
4256 unsafe impl fidl::encoding::TypeMarker for ControlResetResponse {
4257 type Owned = Self;
4258
4259 #[inline(always)]
4260 fn inline_align(_context: fidl::encoding::Context) -> usize {
4261 8
4262 }
4263
4264 #[inline(always)]
4265 fn inline_size(_context: fidl::encoding::Context) -> usize {
4266 16
4267 }
4268 }
4269
4270 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlResetResponse, D>
4271 for &ControlResetResponse
4272 {
4273 unsafe fn encode(
4274 self,
4275 encoder: &mut fidl::encoding::Encoder<'_, D>,
4276 offset: usize,
4277 mut depth: fidl::encoding::Depth,
4278 ) -> fidl::Result<()> {
4279 encoder.debug_check_bounds::<ControlResetResponse>(offset);
4280 let max_ordinal: u64 = self.max_ordinal_present();
4282 encoder.write_num(max_ordinal, offset);
4283 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4284 if max_ordinal == 0 {
4286 return Ok(());
4287 }
4288 depth.increment()?;
4289 let envelope_size = 8;
4290 let bytes_len = max_ordinal as usize * envelope_size;
4291 #[allow(unused_variables)]
4292 let offset = encoder.out_of_line_offset(bytes_len);
4293 let mut _prev_end_offset: usize = 0;
4294
4295 Ok(())
4296 }
4297 }
4298
4299 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetResponse {
4300 #[inline(always)]
4301 fn new_empty() -> Self {
4302 Self::default()
4303 }
4304
4305 unsafe fn decode(
4306 &mut self,
4307 decoder: &mut fidl::encoding::Decoder<'_, D>,
4308 offset: usize,
4309 mut depth: fidl::encoding::Depth,
4310 ) -> fidl::Result<()> {
4311 decoder.debug_check_bounds::<Self>(offset);
4312 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4313 None => return Err(fidl::Error::NotNullable),
4314 Some(len) => len,
4315 };
4316 if len == 0 {
4318 return Ok(());
4319 };
4320 depth.increment()?;
4321 let envelope_size = 8;
4322 let bytes_len = len * envelope_size;
4323 let offset = decoder.out_of_line_offset(bytes_len)?;
4324 let mut _next_ordinal_to_read = 0;
4326 let mut next_offset = offset;
4327 let end_offset = offset + bytes_len;
4328
4329 while next_offset < end_offset {
4331 _next_ordinal_to_read += 1;
4332 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4333 next_offset += envelope_size;
4334 }
4335
4336 Ok(())
4337 }
4338 }
4339
4340 impl ControlSetDaiFormatResponse {
4341 #[inline(always)]
4342 fn max_ordinal_present(&self) -> u64 {
4343 if let Some(_) = self.state {
4344 return 1;
4345 }
4346 0
4347 }
4348 }
4349
4350 impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatResponse {
4351 type Borrowed<'a> = &'a Self;
4352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4353 value
4354 }
4355 }
4356
4357 unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatResponse {
4358 type Owned = Self;
4359
4360 #[inline(always)]
4361 fn inline_align(_context: fidl::encoding::Context) -> usize {
4362 8
4363 }
4364
4365 #[inline(always)]
4366 fn inline_size(_context: fidl::encoding::Context) -> usize {
4367 16
4368 }
4369 }
4370
4371 unsafe impl<D: fidl::encoding::ResourceDialect>
4372 fidl::encoding::Encode<ControlSetDaiFormatResponse, D> for &ControlSetDaiFormatResponse
4373 {
4374 unsafe fn encode(
4375 self,
4376 encoder: &mut fidl::encoding::Encoder<'_, D>,
4377 offset: usize,
4378 mut depth: fidl::encoding::Depth,
4379 ) -> fidl::Result<()> {
4380 encoder.debug_check_bounds::<ControlSetDaiFormatResponse>(offset);
4381 let max_ordinal: u64 = self.max_ordinal_present();
4383 encoder.write_num(max_ordinal, offset);
4384 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4385 if max_ordinal == 0 {
4387 return Ok(());
4388 }
4389 depth.increment()?;
4390 let envelope_size = 8;
4391 let bytes_len = max_ordinal as usize * envelope_size;
4392 #[allow(unused_variables)]
4393 let offset = encoder.out_of_line_offset(bytes_len);
4394 let mut _prev_end_offset: usize = 0;
4395 if 1 > max_ordinal {
4396 return Ok(());
4397 }
4398
4399 let cur_offset: usize = (1 - 1) * envelope_size;
4402
4403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4405
4406 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D>(
4411 self.state.as_ref().map(<fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::ValueTypeMarker>::borrow),
4412 encoder, offset + cur_offset, depth
4413 )?;
4414
4415 _prev_end_offset = cur_offset + envelope_size;
4416
4417 Ok(())
4418 }
4419 }
4420
4421 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4422 for ControlSetDaiFormatResponse
4423 {
4424 #[inline(always)]
4425 fn new_empty() -> Self {
4426 Self::default()
4427 }
4428
4429 unsafe fn decode(
4430 &mut self,
4431 decoder: &mut fidl::encoding::Decoder<'_, D>,
4432 offset: usize,
4433 mut depth: fidl::encoding::Depth,
4434 ) -> fidl::Result<()> {
4435 decoder.debug_check_bounds::<Self>(offset);
4436 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4437 None => return Err(fidl::Error::NotNullable),
4438 Some(len) => len,
4439 };
4440 if len == 0 {
4442 return Ok(());
4443 };
4444 depth.increment()?;
4445 let envelope_size = 8;
4446 let bytes_len = len * envelope_size;
4447 let offset = decoder.out_of_line_offset(bytes_len)?;
4448 let mut _next_ordinal_to_read = 0;
4450 let mut next_offset = offset;
4451 let end_offset = offset + bytes_len;
4452 _next_ordinal_to_read += 1;
4453 if next_offset >= end_offset {
4454 return Ok(());
4455 }
4456
4457 while _next_ordinal_to_read < 1 {
4459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4460 _next_ordinal_to_read += 1;
4461 next_offset += envelope_size;
4462 }
4463
4464 let next_out_of_line = decoder.next_out_of_line();
4465 let handles_before = decoder.remaining_handles();
4466 if let Some((inlined, num_bytes, num_handles)) =
4467 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4468 {
4469 let member_inline_size = <fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4470 if inlined != (member_inline_size <= 4) {
4471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4472 }
4473 let inner_offset;
4474 let mut inner_depth = depth.clone();
4475 if inlined {
4476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4477 inner_offset = next_offset;
4478 } else {
4479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4480 inner_depth.increment()?;
4481 }
4482 let val_ref = self.state.get_or_insert_with(|| {
4483 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D)
4484 });
4485 fidl::decode!(
4486 fidl_fuchsia_hardware_audio__common::CodecFormatInfo,
4487 D,
4488 val_ref,
4489 decoder,
4490 inner_offset,
4491 inner_depth
4492 )?;
4493 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4494 {
4495 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4496 }
4497 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4498 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4499 }
4500 }
4501
4502 next_offset += envelope_size;
4503
4504 while next_offset < end_offset {
4506 _next_ordinal_to_read += 1;
4507 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4508 next_offset += envelope_size;
4509 }
4510
4511 Ok(())
4512 }
4513 }
4514
4515 impl DelayInfo {
4516 #[inline(always)]
4517 fn max_ordinal_present(&self) -> u64 {
4518 if let Some(_) = self.external_delay {
4519 return 2;
4520 }
4521 if let Some(_) = self.internal_delay {
4522 return 1;
4523 }
4524 0
4525 }
4526 }
4527
4528 impl fidl::encoding::ValueTypeMarker for DelayInfo {
4529 type Borrowed<'a> = &'a Self;
4530 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4531 value
4532 }
4533 }
4534
4535 unsafe impl fidl::encoding::TypeMarker for DelayInfo {
4536 type Owned = Self;
4537
4538 #[inline(always)]
4539 fn inline_align(_context: fidl::encoding::Context) -> usize {
4540 8
4541 }
4542
4543 #[inline(always)]
4544 fn inline_size(_context: fidl::encoding::Context) -> usize {
4545 16
4546 }
4547 }
4548
4549 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DelayInfo, D>
4550 for &DelayInfo
4551 {
4552 unsafe fn encode(
4553 self,
4554 encoder: &mut fidl::encoding::Encoder<'_, D>,
4555 offset: usize,
4556 mut depth: fidl::encoding::Depth,
4557 ) -> fidl::Result<()> {
4558 encoder.debug_check_bounds::<DelayInfo>(offset);
4559 let max_ordinal: u64 = self.max_ordinal_present();
4561 encoder.write_num(max_ordinal, offset);
4562 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4563 if max_ordinal == 0 {
4565 return Ok(());
4566 }
4567 depth.increment()?;
4568 let envelope_size = 8;
4569 let bytes_len = max_ordinal as usize * envelope_size;
4570 #[allow(unused_variables)]
4571 let offset = encoder.out_of_line_offset(bytes_len);
4572 let mut _prev_end_offset: usize = 0;
4573 if 1 > max_ordinal {
4574 return Ok(());
4575 }
4576
4577 let cur_offset: usize = (1 - 1) * envelope_size;
4580
4581 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4583
4584 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4589 self.internal_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4590 encoder,
4591 offset + cur_offset,
4592 depth,
4593 )?;
4594
4595 _prev_end_offset = cur_offset + envelope_size;
4596 if 2 > max_ordinal {
4597 return Ok(());
4598 }
4599
4600 let cur_offset: usize = (2 - 1) * envelope_size;
4603
4604 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4606
4607 fidl::encoding::encode_in_envelope_optional::<i64, D>(
4612 self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4613 encoder,
4614 offset + cur_offset,
4615 depth,
4616 )?;
4617
4618 _prev_end_offset = cur_offset + envelope_size;
4619
4620 Ok(())
4621 }
4622 }
4623
4624 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DelayInfo {
4625 #[inline(always)]
4626 fn new_empty() -> Self {
4627 Self::default()
4628 }
4629
4630 unsafe fn decode(
4631 &mut self,
4632 decoder: &mut fidl::encoding::Decoder<'_, D>,
4633 offset: usize,
4634 mut depth: fidl::encoding::Depth,
4635 ) -> fidl::Result<()> {
4636 decoder.debug_check_bounds::<Self>(offset);
4637 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4638 None => return Err(fidl::Error::NotNullable),
4639 Some(len) => len,
4640 };
4641 if len == 0 {
4643 return Ok(());
4644 };
4645 depth.increment()?;
4646 let envelope_size = 8;
4647 let bytes_len = len * envelope_size;
4648 let offset = decoder.out_of_line_offset(bytes_len)?;
4649 let mut _next_ordinal_to_read = 0;
4651 let mut next_offset = offset;
4652 let end_offset = offset + bytes_len;
4653 _next_ordinal_to_read += 1;
4654 if next_offset >= end_offset {
4655 return Ok(());
4656 }
4657
4658 while _next_ordinal_to_read < 1 {
4660 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4661 _next_ordinal_to_read += 1;
4662 next_offset += envelope_size;
4663 }
4664
4665 let next_out_of_line = decoder.next_out_of_line();
4666 let handles_before = decoder.remaining_handles();
4667 if let Some((inlined, num_bytes, num_handles)) =
4668 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4669 {
4670 let member_inline_size =
4671 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4672 if inlined != (member_inline_size <= 4) {
4673 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4674 }
4675 let inner_offset;
4676 let mut inner_depth = depth.clone();
4677 if inlined {
4678 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4679 inner_offset = next_offset;
4680 } else {
4681 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4682 inner_depth.increment()?;
4683 }
4684 let val_ref = self.internal_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4685 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4686 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4687 {
4688 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4689 }
4690 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4691 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4692 }
4693 }
4694
4695 next_offset += envelope_size;
4696 _next_ordinal_to_read += 1;
4697 if next_offset >= end_offset {
4698 return Ok(());
4699 }
4700
4701 while _next_ordinal_to_read < 2 {
4703 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4704 _next_ordinal_to_read += 1;
4705 next_offset += envelope_size;
4706 }
4707
4708 let next_out_of_line = decoder.next_out_of_line();
4709 let handles_before = decoder.remaining_handles();
4710 if let Some((inlined, num_bytes, num_handles)) =
4711 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4712 {
4713 let member_inline_size =
4714 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4715 if inlined != (member_inline_size <= 4) {
4716 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4717 }
4718 let inner_offset;
4719 let mut inner_depth = depth.clone();
4720 if inlined {
4721 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4722 inner_offset = next_offset;
4723 } else {
4724 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4725 inner_depth.increment()?;
4726 }
4727 let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4728 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4729 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4730 {
4731 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4732 }
4733 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4734 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4735 }
4736 }
4737
4738 next_offset += envelope_size;
4739
4740 while next_offset < end_offset {
4742 _next_ordinal_to_read += 1;
4743 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4744 next_offset += envelope_size;
4745 }
4746
4747 Ok(())
4748 }
4749 }
4750
4751 impl ElementDaiFormatSet {
4752 #[inline(always)]
4753 fn max_ordinal_present(&self) -> u64 {
4754 if let Some(_) = self.format_sets {
4755 return 2;
4756 }
4757 if let Some(_) = self.element_id {
4758 return 1;
4759 }
4760 0
4761 }
4762 }
4763
4764 impl fidl::encoding::ValueTypeMarker for ElementDaiFormatSet {
4765 type Borrowed<'a> = &'a Self;
4766 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4767 value
4768 }
4769 }
4770
4771 unsafe impl fidl::encoding::TypeMarker for ElementDaiFormatSet {
4772 type Owned = Self;
4773
4774 #[inline(always)]
4775 fn inline_align(_context: fidl::encoding::Context) -> usize {
4776 8
4777 }
4778
4779 #[inline(always)]
4780 fn inline_size(_context: fidl::encoding::Context) -> usize {
4781 16
4782 }
4783 }
4784
4785 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementDaiFormatSet, D>
4786 for &ElementDaiFormatSet
4787 {
4788 unsafe fn encode(
4789 self,
4790 encoder: &mut fidl::encoding::Encoder<'_, D>,
4791 offset: usize,
4792 mut depth: fidl::encoding::Depth,
4793 ) -> fidl::Result<()> {
4794 encoder.debug_check_bounds::<ElementDaiFormatSet>(offset);
4795 let max_ordinal: u64 = self.max_ordinal_present();
4797 encoder.write_num(max_ordinal, offset);
4798 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4799 if max_ordinal == 0 {
4801 return Ok(());
4802 }
4803 depth.increment()?;
4804 let envelope_size = 8;
4805 let bytes_len = max_ordinal as usize * envelope_size;
4806 #[allow(unused_variables)]
4807 let offset = encoder.out_of_line_offset(bytes_len);
4808 let mut _prev_end_offset: usize = 0;
4809 if 1 > max_ordinal {
4810 return Ok(());
4811 }
4812
4813 let cur_offset: usize = (1 - 1) * envelope_size;
4816
4817 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4819
4820 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4825 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4826 encoder,
4827 offset + cur_offset,
4828 depth,
4829 )?;
4830
4831 _prev_end_offset = cur_offset + envelope_size;
4832 if 2 > max_ordinal {
4833 return Ok(());
4834 }
4835
4836 let cur_offset: usize = (2 - 1) * envelope_size;
4839
4840 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4842
4843 fidl::encoding::encode_in_envelope_optional::<
4848 fidl::encoding::Vector<
4849 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4850 64,
4851 >,
4852 D,
4853 >(
4854 self.format_sets.as_ref().map(
4855 <fidl::encoding::Vector<
4856 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4857 64,
4858 > as fidl::encoding::ValueTypeMarker>::borrow,
4859 ),
4860 encoder,
4861 offset + cur_offset,
4862 depth,
4863 )?;
4864
4865 _prev_end_offset = cur_offset + envelope_size;
4866
4867 Ok(())
4868 }
4869 }
4870
4871 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementDaiFormatSet {
4872 #[inline(always)]
4873 fn new_empty() -> Self {
4874 Self::default()
4875 }
4876
4877 unsafe fn decode(
4878 &mut self,
4879 decoder: &mut fidl::encoding::Decoder<'_, D>,
4880 offset: usize,
4881 mut depth: fidl::encoding::Depth,
4882 ) -> fidl::Result<()> {
4883 decoder.debug_check_bounds::<Self>(offset);
4884 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4885 None => return Err(fidl::Error::NotNullable),
4886 Some(len) => len,
4887 };
4888 if len == 0 {
4890 return Ok(());
4891 };
4892 depth.increment()?;
4893 let envelope_size = 8;
4894 let bytes_len = len * envelope_size;
4895 let offset = decoder.out_of_line_offset(bytes_len)?;
4896 let mut _next_ordinal_to_read = 0;
4898 let mut next_offset = offset;
4899 let end_offset = offset + bytes_len;
4900 _next_ordinal_to_read += 1;
4901 if next_offset >= end_offset {
4902 return Ok(());
4903 }
4904
4905 while _next_ordinal_to_read < 1 {
4907 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4908 _next_ordinal_to_read += 1;
4909 next_offset += envelope_size;
4910 }
4911
4912 let next_out_of_line = decoder.next_out_of_line();
4913 let handles_before = decoder.remaining_handles();
4914 if let Some((inlined, num_bytes, num_handles)) =
4915 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4916 {
4917 let member_inline_size =
4918 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4919 if inlined != (member_inline_size <= 4) {
4920 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4921 }
4922 let inner_offset;
4923 let mut inner_depth = depth.clone();
4924 if inlined {
4925 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4926 inner_offset = next_offset;
4927 } else {
4928 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4929 inner_depth.increment()?;
4930 }
4931 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4932 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934 {
4935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936 }
4937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939 }
4940 }
4941
4942 next_offset += envelope_size;
4943 _next_ordinal_to_read += 1;
4944 if next_offset >= end_offset {
4945 return Ok(());
4946 }
4947
4948 while _next_ordinal_to_read < 2 {
4950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951 _next_ordinal_to_read += 1;
4952 next_offset += envelope_size;
4953 }
4954
4955 let next_out_of_line = decoder.next_out_of_line();
4956 let handles_before = decoder.remaining_handles();
4957 if let Some((inlined, num_bytes, num_handles)) =
4958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959 {
4960 let member_inline_size = <fidl::encoding::Vector<
4961 fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4962 64,
4963 > as fidl::encoding::TypeMarker>::inline_size(
4964 decoder.context
4965 );
4966 if inlined != (member_inline_size <= 4) {
4967 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4968 }
4969 let inner_offset;
4970 let mut inner_depth = depth.clone();
4971 if inlined {
4972 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4973 inner_offset = next_offset;
4974 } else {
4975 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4976 inner_depth.increment()?;
4977 }
4978 let val_ref =
4979 self.format_sets.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D));
4980 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4981 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4982 {
4983 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4984 }
4985 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4986 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4987 }
4988 }
4989
4990 next_offset += envelope_size;
4991
4992 while next_offset < end_offset {
4994 _next_ordinal_to_read += 1;
4995 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4996 next_offset += envelope_size;
4997 }
4998
4999 Ok(())
5000 }
5001 }
5002
5003 impl ElementRingBufferFormatSet {
5004 #[inline(always)]
5005 fn max_ordinal_present(&self) -> u64 {
5006 if let Some(_) = self.format_sets {
5007 return 2;
5008 }
5009 if let Some(_) = self.element_id {
5010 return 1;
5011 }
5012 0
5013 }
5014 }
5015
5016 impl fidl::encoding::ValueTypeMarker for ElementRingBufferFormatSet {
5017 type Borrowed<'a> = &'a Self;
5018 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5019 value
5020 }
5021 }
5022
5023 unsafe impl fidl::encoding::TypeMarker for ElementRingBufferFormatSet {
5024 type Owned = Self;
5025
5026 #[inline(always)]
5027 fn inline_align(_context: fidl::encoding::Context) -> usize {
5028 8
5029 }
5030
5031 #[inline(always)]
5032 fn inline_size(_context: fidl::encoding::Context) -> usize {
5033 16
5034 }
5035 }
5036
5037 unsafe impl<D: fidl::encoding::ResourceDialect>
5038 fidl::encoding::Encode<ElementRingBufferFormatSet, D> for &ElementRingBufferFormatSet
5039 {
5040 unsafe fn encode(
5041 self,
5042 encoder: &mut fidl::encoding::Encoder<'_, D>,
5043 offset: usize,
5044 mut depth: fidl::encoding::Depth,
5045 ) -> fidl::Result<()> {
5046 encoder.debug_check_bounds::<ElementRingBufferFormatSet>(offset);
5047 let max_ordinal: u64 = self.max_ordinal_present();
5049 encoder.write_num(max_ordinal, offset);
5050 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5051 if max_ordinal == 0 {
5053 return Ok(());
5054 }
5055 depth.increment()?;
5056 let envelope_size = 8;
5057 let bytes_len = max_ordinal as usize * envelope_size;
5058 #[allow(unused_variables)]
5059 let offset = encoder.out_of_line_offset(bytes_len);
5060 let mut _prev_end_offset: usize = 0;
5061 if 1 > max_ordinal {
5062 return Ok(());
5063 }
5064
5065 let cur_offset: usize = (1 - 1) * envelope_size;
5068
5069 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5071
5072 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5077 self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5078 encoder,
5079 offset + cur_offset,
5080 depth,
5081 )?;
5082
5083 _prev_end_offset = cur_offset + envelope_size;
5084 if 2 > max_ordinal {
5085 return Ok(());
5086 }
5087
5088 let cur_offset: usize = (2 - 1) * envelope_size;
5091
5092 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5094
5095 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PcmFormatSet, 64>, D>(
5100 self.format_sets.as_ref().map(<fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5101 encoder, offset + cur_offset, depth
5102 )?;
5103
5104 _prev_end_offset = cur_offset + envelope_size;
5105
5106 Ok(())
5107 }
5108 }
5109
5110 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5111 for ElementRingBufferFormatSet
5112 {
5113 #[inline(always)]
5114 fn new_empty() -> Self {
5115 Self::default()
5116 }
5117
5118 unsafe fn decode(
5119 &mut self,
5120 decoder: &mut fidl::encoding::Decoder<'_, D>,
5121 offset: usize,
5122 mut depth: fidl::encoding::Depth,
5123 ) -> fidl::Result<()> {
5124 decoder.debug_check_bounds::<Self>(offset);
5125 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5126 None => return Err(fidl::Error::NotNullable),
5127 Some(len) => len,
5128 };
5129 if len == 0 {
5131 return Ok(());
5132 };
5133 depth.increment()?;
5134 let envelope_size = 8;
5135 let bytes_len = len * envelope_size;
5136 let offset = decoder.out_of_line_offset(bytes_len)?;
5137 let mut _next_ordinal_to_read = 0;
5139 let mut next_offset = offset;
5140 let end_offset = offset + bytes_len;
5141 _next_ordinal_to_read += 1;
5142 if next_offset >= end_offset {
5143 return Ok(());
5144 }
5145
5146 while _next_ordinal_to_read < 1 {
5148 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5149 _next_ordinal_to_read += 1;
5150 next_offset += envelope_size;
5151 }
5152
5153 let next_out_of_line = decoder.next_out_of_line();
5154 let handles_before = decoder.remaining_handles();
5155 if let Some((inlined, num_bytes, num_handles)) =
5156 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5157 {
5158 let member_inline_size =
5159 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5160 if inlined != (member_inline_size <= 4) {
5161 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5162 }
5163 let inner_offset;
5164 let mut inner_depth = depth.clone();
5165 if inlined {
5166 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5167 inner_offset = next_offset;
5168 } else {
5169 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5170 inner_depth.increment()?;
5171 }
5172 let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5173 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5174 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5175 {
5176 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5177 }
5178 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5179 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5180 }
5181 }
5182
5183 next_offset += envelope_size;
5184 _next_ordinal_to_read += 1;
5185 if next_offset >= end_offset {
5186 return Ok(());
5187 }
5188
5189 while _next_ordinal_to_read < 2 {
5191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5192 _next_ordinal_to_read += 1;
5193 next_offset += envelope_size;
5194 }
5195
5196 let next_out_of_line = decoder.next_out_of_line();
5197 let handles_before = decoder.remaining_handles();
5198 if let Some((inlined, num_bytes, num_handles)) =
5199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5200 {
5201 let member_inline_size = <fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5202 if inlined != (member_inline_size <= 4) {
5203 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5204 }
5205 let inner_offset;
5206 let mut inner_depth = depth.clone();
5207 if inlined {
5208 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5209 inner_offset = next_offset;
5210 } else {
5211 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5212 inner_depth.increment()?;
5213 }
5214 let val_ref = self.format_sets.get_or_insert_with(
5215 || fidl::new_empty!(fidl::encoding::Vector<PcmFormatSet, 64>, D),
5216 );
5217 fidl::decode!(fidl::encoding::Vector<PcmFormatSet, 64>, 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
5229 while next_offset < end_offset {
5231 _next_ordinal_to_read += 1;
5232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5233 next_offset += envelope_size;
5234 }
5235
5236 Ok(())
5237 }
5238 }
5239
5240 impl Info {
5241 #[inline(always)]
5242 fn max_ordinal_present(&self) -> u64 {
5243 if let Some(_) = self.signal_processing_topologies {
5244 return 13;
5245 }
5246 if let Some(_) = self.signal_processing_elements {
5247 return 12;
5248 }
5249 if let Some(_) = self.clock_domain {
5250 return 11;
5251 }
5252 if let Some(_) = self.plug_detect_caps {
5253 return 10;
5254 }
5255 if let Some(_) = self.dai_format_sets {
5256 return 9;
5257 }
5258 if let Some(_) = self.ring_buffer_format_sets {
5259 return 8;
5260 }
5261 if let Some(_) = self.is_input {
5262 return 7;
5263 }
5264 if let Some(_) = self.unique_instance_id {
5265 return 6;
5266 }
5267 if let Some(_) = self.product {
5268 return 5;
5269 }
5270 if let Some(_) = self.manufacturer {
5271 return 4;
5272 }
5273 if let Some(_) = self.device_name {
5274 return 3;
5275 }
5276 if let Some(_) = self.device_type {
5277 return 2;
5278 }
5279 if let Some(_) = self.token_id {
5280 return 1;
5281 }
5282 0
5283 }
5284 }
5285
5286 impl fidl::encoding::ValueTypeMarker for Info {
5287 type Borrowed<'a> = &'a Self;
5288 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5289 value
5290 }
5291 }
5292
5293 unsafe impl fidl::encoding::TypeMarker for Info {
5294 type Owned = Self;
5295
5296 #[inline(always)]
5297 fn inline_align(_context: fidl::encoding::Context) -> usize {
5298 8
5299 }
5300
5301 #[inline(always)]
5302 fn inline_size(_context: fidl::encoding::Context) -> usize {
5303 16
5304 }
5305 }
5306
5307 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Info, D> for &Info {
5308 unsafe fn encode(
5309 self,
5310 encoder: &mut fidl::encoding::Encoder<'_, D>,
5311 offset: usize,
5312 mut depth: fidl::encoding::Depth,
5313 ) -> fidl::Result<()> {
5314 encoder.debug_check_bounds::<Info>(offset);
5315 let max_ordinal: u64 = self.max_ordinal_present();
5317 encoder.write_num(max_ordinal, offset);
5318 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5319 if max_ordinal == 0 {
5321 return Ok(());
5322 }
5323 depth.increment()?;
5324 let envelope_size = 8;
5325 let bytes_len = max_ordinal as usize * envelope_size;
5326 #[allow(unused_variables)]
5327 let offset = encoder.out_of_line_offset(bytes_len);
5328 let mut _prev_end_offset: usize = 0;
5329 if 1 > max_ordinal {
5330 return Ok(());
5331 }
5332
5333 let cur_offset: usize = (1 - 1) * envelope_size;
5336
5337 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5339
5340 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5345 self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5346 encoder,
5347 offset + cur_offset,
5348 depth,
5349 )?;
5350
5351 _prev_end_offset = cur_offset + envelope_size;
5352 if 2 > max_ordinal {
5353 return Ok(());
5354 }
5355
5356 let cur_offset: usize = (2 - 1) * envelope_size;
5359
5360 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5362
5363 fidl::encoding::encode_in_envelope_optional::<DeviceType, D>(
5368 self.device_type
5369 .as_ref()
5370 .map(<DeviceType as fidl::encoding::ValueTypeMarker>::borrow),
5371 encoder,
5372 offset + cur_offset,
5373 depth,
5374 )?;
5375
5376 _prev_end_offset = cur_offset + envelope_size;
5377 if 3 > max_ordinal {
5378 return Ok(());
5379 }
5380
5381 let cur_offset: usize = (3 - 1) * envelope_size;
5384
5385 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5387
5388 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5393 self.device_name.as_ref().map(
5394 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5395 ),
5396 encoder,
5397 offset + cur_offset,
5398 depth,
5399 )?;
5400
5401 _prev_end_offset = cur_offset + envelope_size;
5402 if 4 > max_ordinal {
5403 return Ok(());
5404 }
5405
5406 let cur_offset: usize = (4 - 1) * envelope_size;
5409
5410 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5412
5413 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5418 self.manufacturer.as_ref().map(
5419 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5420 ),
5421 encoder,
5422 offset + cur_offset,
5423 depth,
5424 )?;
5425
5426 _prev_end_offset = cur_offset + envelope_size;
5427 if 5 > max_ordinal {
5428 return Ok(());
5429 }
5430
5431 let cur_offset: usize = (5 - 1) * envelope_size;
5434
5435 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5437
5438 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5443 self.product.as_ref().map(
5444 <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5445 ),
5446 encoder,
5447 offset + cur_offset,
5448 depth,
5449 )?;
5450
5451 _prev_end_offset = cur_offset + envelope_size;
5452 if 6 > max_ordinal {
5453 return Ok(());
5454 }
5455
5456 let cur_offset: usize = (6 - 1) * envelope_size;
5459
5460 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5462
5463 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
5468 self.unique_instance_id.as_ref().map(
5469 <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
5470 ),
5471 encoder,
5472 offset + cur_offset,
5473 depth,
5474 )?;
5475
5476 _prev_end_offset = cur_offset + envelope_size;
5477 if 7 > max_ordinal {
5478 return Ok(());
5479 }
5480
5481 let cur_offset: usize = (7 - 1) * envelope_size;
5484
5485 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5487
5488 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5493 self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5494 encoder,
5495 offset + cur_offset,
5496 depth,
5497 )?;
5498
5499 _prev_end_offset = cur_offset + envelope_size;
5500 if 8 > max_ordinal {
5501 return Ok(());
5502 }
5503
5504 let cur_offset: usize = (8 - 1) * envelope_size;
5507
5508 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5510
5511 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D>(
5516 self.ring_buffer_format_sets.as_ref().map(<fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5517 encoder, offset + cur_offset, depth
5518 )?;
5519
5520 _prev_end_offset = cur_offset + envelope_size;
5521 if 9 > max_ordinal {
5522 return Ok(());
5523 }
5524
5525 let cur_offset: usize = (9 - 1) * envelope_size;
5528
5529 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5531
5532 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementDaiFormatSet, 64>, D>(
5537 self.dai_format_sets.as_ref().map(<fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5538 encoder, offset + cur_offset, depth
5539 )?;
5540
5541 _prev_end_offset = cur_offset + envelope_size;
5542 if 10 > max_ordinal {
5543 return Ok(());
5544 }
5545
5546 let cur_offset: usize = (10 - 1) * envelope_size;
5549
5550 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5552
5553 fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
5558 self.plug_detect_caps
5559 .as_ref()
5560 .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
5561 encoder,
5562 offset + cur_offset,
5563 depth,
5564 )?;
5565
5566 _prev_end_offset = cur_offset + envelope_size;
5567 if 11 > max_ordinal {
5568 return Ok(());
5569 }
5570
5571 let cur_offset: usize = (11 - 1) * envelope_size;
5574
5575 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5577
5578 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5583 self.clock_domain.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5584 encoder,
5585 offset + cur_offset,
5586 depth,
5587 )?;
5588
5589 _prev_end_offset = cur_offset + envelope_size;
5590 if 12 > max_ordinal {
5591 return Ok(());
5592 }
5593
5594 let cur_offset: usize = (12 - 1) * envelope_size;
5597
5598 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5600
5601 fidl::encoding::encode_in_envelope_optional::<
5606 fidl::encoding::Vector<
5607 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5608 64,
5609 >,
5610 D,
5611 >(
5612 self.signal_processing_elements.as_ref().map(
5613 <fidl::encoding::Vector<
5614 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5615 64,
5616 > as fidl::encoding::ValueTypeMarker>::borrow,
5617 ),
5618 encoder,
5619 offset + cur_offset,
5620 depth,
5621 )?;
5622
5623 _prev_end_offset = cur_offset + envelope_size;
5624 if 13 > max_ordinal {
5625 return Ok(());
5626 }
5627
5628 let cur_offset: usize = (13 - 1) * envelope_size;
5631
5632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5634
5635 fidl::encoding::encode_in_envelope_optional::<
5640 fidl::encoding::Vector<
5641 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5642 64,
5643 >,
5644 D,
5645 >(
5646 self.signal_processing_topologies.as_ref().map(
5647 <fidl::encoding::Vector<
5648 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5649 64,
5650 > as fidl::encoding::ValueTypeMarker>::borrow,
5651 ),
5652 encoder,
5653 offset + cur_offset,
5654 depth,
5655 )?;
5656
5657 _prev_end_offset = cur_offset + envelope_size;
5658
5659 Ok(())
5660 }
5661 }
5662
5663 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Info {
5664 #[inline(always)]
5665 fn new_empty() -> Self {
5666 Self::default()
5667 }
5668
5669 unsafe fn decode(
5670 &mut self,
5671 decoder: &mut fidl::encoding::Decoder<'_, D>,
5672 offset: usize,
5673 mut depth: fidl::encoding::Depth,
5674 ) -> fidl::Result<()> {
5675 decoder.debug_check_bounds::<Self>(offset);
5676 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5677 None => return Err(fidl::Error::NotNullable),
5678 Some(len) => len,
5679 };
5680 if len == 0 {
5682 return Ok(());
5683 };
5684 depth.increment()?;
5685 let envelope_size = 8;
5686 let bytes_len = len * envelope_size;
5687 let offset = decoder.out_of_line_offset(bytes_len)?;
5688 let mut _next_ordinal_to_read = 0;
5690 let mut next_offset = offset;
5691 let end_offset = offset + bytes_len;
5692 _next_ordinal_to_read += 1;
5693 if next_offset >= end_offset {
5694 return Ok(());
5695 }
5696
5697 while _next_ordinal_to_read < 1 {
5699 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5700 _next_ordinal_to_read += 1;
5701 next_offset += envelope_size;
5702 }
5703
5704 let next_out_of_line = decoder.next_out_of_line();
5705 let handles_before = decoder.remaining_handles();
5706 if let Some((inlined, num_bytes, num_handles)) =
5707 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5708 {
5709 let member_inline_size =
5710 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5711 if inlined != (member_inline_size <= 4) {
5712 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5713 }
5714 let inner_offset;
5715 let mut inner_depth = depth.clone();
5716 if inlined {
5717 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5718 inner_offset = next_offset;
5719 } else {
5720 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5721 inner_depth.increment()?;
5722 }
5723 let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5724 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5725 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5726 {
5727 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5728 }
5729 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5730 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5731 }
5732 }
5733
5734 next_offset += envelope_size;
5735 _next_ordinal_to_read += 1;
5736 if next_offset >= end_offset {
5737 return Ok(());
5738 }
5739
5740 while _next_ordinal_to_read < 2 {
5742 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5743 _next_ordinal_to_read += 1;
5744 next_offset += envelope_size;
5745 }
5746
5747 let next_out_of_line = decoder.next_out_of_line();
5748 let handles_before = decoder.remaining_handles();
5749 if let Some((inlined, num_bytes, num_handles)) =
5750 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5751 {
5752 let member_inline_size =
5753 <DeviceType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5754 if inlined != (member_inline_size <= 4) {
5755 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5756 }
5757 let inner_offset;
5758 let mut inner_depth = depth.clone();
5759 if inlined {
5760 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5761 inner_offset = next_offset;
5762 } else {
5763 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5764 inner_depth.increment()?;
5765 }
5766 let val_ref =
5767 self.device_type.get_or_insert_with(|| fidl::new_empty!(DeviceType, D));
5768 fidl::decode!(DeviceType, 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 < 3 {
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 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5798 decoder.context,
5799 );
5800 if inlined != (member_inline_size <= 4) {
5801 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5802 }
5803 let inner_offset;
5804 let mut inner_depth = depth.clone();
5805 if inlined {
5806 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5807 inner_offset = next_offset;
5808 } else {
5809 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5810 inner_depth.increment()?;
5811 }
5812 let val_ref = self
5813 .device_name
5814 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5815 fidl::decode!(
5816 fidl::encoding::BoundedString<256>,
5817 D,
5818 val_ref,
5819 decoder,
5820 inner_offset,
5821 inner_depth
5822 )?;
5823 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5824 {
5825 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5826 }
5827 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5828 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5829 }
5830 }
5831
5832 next_offset += envelope_size;
5833 _next_ordinal_to_read += 1;
5834 if next_offset >= end_offset {
5835 return Ok(());
5836 }
5837
5838 while _next_ordinal_to_read < 4 {
5840 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5841 _next_ordinal_to_read += 1;
5842 next_offset += envelope_size;
5843 }
5844
5845 let next_out_of_line = decoder.next_out_of_line();
5846 let handles_before = decoder.remaining_handles();
5847 if let Some((inlined, num_bytes, num_handles)) =
5848 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5849 {
5850 let member_inline_size =
5851 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5852 decoder.context,
5853 );
5854 if inlined != (member_inline_size <= 4) {
5855 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5856 }
5857 let inner_offset;
5858 let mut inner_depth = depth.clone();
5859 if inlined {
5860 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5861 inner_offset = next_offset;
5862 } else {
5863 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5864 inner_depth.increment()?;
5865 }
5866 let val_ref = self
5867 .manufacturer
5868 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5869 fidl::decode!(
5870 fidl::encoding::BoundedString<256>,
5871 D,
5872 val_ref,
5873 decoder,
5874 inner_offset,
5875 inner_depth
5876 )?;
5877 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5878 {
5879 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5880 }
5881 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5882 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5883 }
5884 }
5885
5886 next_offset += envelope_size;
5887 _next_ordinal_to_read += 1;
5888 if next_offset >= end_offset {
5889 return Ok(());
5890 }
5891
5892 while _next_ordinal_to_read < 5 {
5894 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5895 _next_ordinal_to_read += 1;
5896 next_offset += envelope_size;
5897 }
5898
5899 let next_out_of_line = decoder.next_out_of_line();
5900 let handles_before = decoder.remaining_handles();
5901 if let Some((inlined, num_bytes, num_handles)) =
5902 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5903 {
5904 let member_inline_size =
5905 <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5906 decoder.context,
5907 );
5908 if inlined != (member_inline_size <= 4) {
5909 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5910 }
5911 let inner_offset;
5912 let mut inner_depth = depth.clone();
5913 if inlined {
5914 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5915 inner_offset = next_offset;
5916 } else {
5917 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5918 inner_depth.increment()?;
5919 }
5920 let val_ref = self
5921 .product
5922 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5923 fidl::decode!(
5924 fidl::encoding::BoundedString<256>,
5925 D,
5926 val_ref,
5927 decoder,
5928 inner_offset,
5929 inner_depth
5930 )?;
5931 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5932 {
5933 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5934 }
5935 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5936 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5937 }
5938 }
5939
5940 next_offset += envelope_size;
5941 _next_ordinal_to_read += 1;
5942 if next_offset >= end_offset {
5943 return Ok(());
5944 }
5945
5946 while _next_ordinal_to_read < 6 {
5948 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5949 _next_ordinal_to_read += 1;
5950 next_offset += envelope_size;
5951 }
5952
5953 let next_out_of_line = decoder.next_out_of_line();
5954 let handles_before = decoder.remaining_handles();
5955 if let Some((inlined, num_bytes, num_handles)) =
5956 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5957 {
5958 let member_inline_size =
5959 <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
5960 decoder.context,
5961 );
5962 if inlined != (member_inline_size <= 4) {
5963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5964 }
5965 let inner_offset;
5966 let mut inner_depth = depth.clone();
5967 if inlined {
5968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5969 inner_offset = next_offset;
5970 } else {
5971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5972 inner_depth.increment()?;
5973 }
5974 let val_ref = self
5975 .unique_instance_id
5976 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
5977 fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
5978 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5979 {
5980 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5981 }
5982 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5983 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5984 }
5985 }
5986
5987 next_offset += envelope_size;
5988 _next_ordinal_to_read += 1;
5989 if next_offset >= end_offset {
5990 return Ok(());
5991 }
5992
5993 while _next_ordinal_to_read < 7 {
5995 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5996 _next_ordinal_to_read += 1;
5997 next_offset += envelope_size;
5998 }
5999
6000 let next_out_of_line = decoder.next_out_of_line();
6001 let handles_before = decoder.remaining_handles();
6002 if let Some((inlined, num_bytes, num_handles)) =
6003 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6004 {
6005 let member_inline_size =
6006 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6007 if inlined != (member_inline_size <= 4) {
6008 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6009 }
6010 let inner_offset;
6011 let mut inner_depth = depth.clone();
6012 if inlined {
6013 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6014 inner_offset = next_offset;
6015 } else {
6016 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6017 inner_depth.increment()?;
6018 }
6019 let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
6020 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6021 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6022 {
6023 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6024 }
6025 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6026 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6027 }
6028 }
6029
6030 next_offset += envelope_size;
6031 _next_ordinal_to_read += 1;
6032 if next_offset >= end_offset {
6033 return Ok(());
6034 }
6035
6036 while _next_ordinal_to_read < 8 {
6038 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6039 _next_ordinal_to_read += 1;
6040 next_offset += envelope_size;
6041 }
6042
6043 let next_out_of_line = decoder.next_out_of_line();
6044 let handles_before = decoder.remaining_handles();
6045 if let Some((inlined, num_bytes, num_handles)) =
6046 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6047 {
6048 let member_inline_size = <fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6049 if inlined != (member_inline_size <= 4) {
6050 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6051 }
6052 let inner_offset;
6053 let mut inner_depth = depth.clone();
6054 if inlined {
6055 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6056 inner_offset = next_offset;
6057 } else {
6058 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6059 inner_depth.increment()?;
6060 }
6061 let val_ref = self.ring_buffer_format_sets.get_or_insert_with(
6062 || fidl::new_empty!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D),
6063 );
6064 fidl::decode!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, 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 < 9 {
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<ElementDaiFormatSet, 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.dai_format_sets.get_or_insert_with(
6106 || fidl::new_empty!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D),
6107 );
6108 fidl::decode!(fidl::encoding::Vector<ElementDaiFormatSet, 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 < 10 {
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 =
6137 <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6138 decoder.context,
6139 );
6140 if inlined != (member_inline_size <= 4) {
6141 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6142 }
6143 let inner_offset;
6144 let mut inner_depth = depth.clone();
6145 if inlined {
6146 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6147 inner_offset = next_offset;
6148 } else {
6149 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6150 inner_depth.increment()?;
6151 }
6152 let val_ref = self
6153 .plug_detect_caps
6154 .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6155 fidl::decode!(
6156 PlugDetectCapabilities,
6157 D,
6158 val_ref,
6159 decoder,
6160 inner_offset,
6161 inner_depth
6162 )?;
6163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6164 {
6165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6166 }
6167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6169 }
6170 }
6171
6172 next_offset += envelope_size;
6173 _next_ordinal_to_read += 1;
6174 if next_offset >= end_offset {
6175 return Ok(());
6176 }
6177
6178 while _next_ordinal_to_read < 11 {
6180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6181 _next_ordinal_to_read += 1;
6182 next_offset += envelope_size;
6183 }
6184
6185 let next_out_of_line = decoder.next_out_of_line();
6186 let handles_before = decoder.remaining_handles();
6187 if let Some((inlined, num_bytes, num_handles)) =
6188 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6189 {
6190 let member_inline_size =
6191 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6192 if inlined != (member_inline_size <= 4) {
6193 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6194 }
6195 let inner_offset;
6196 let mut inner_depth = depth.clone();
6197 if inlined {
6198 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6199 inner_offset = next_offset;
6200 } else {
6201 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6202 inner_depth.increment()?;
6203 }
6204 let val_ref = self.clock_domain.get_or_insert_with(|| fidl::new_empty!(u32, D));
6205 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6206 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6207 {
6208 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6209 }
6210 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6211 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6212 }
6213 }
6214
6215 next_offset += envelope_size;
6216 _next_ordinal_to_read += 1;
6217 if next_offset >= end_offset {
6218 return Ok(());
6219 }
6220
6221 while _next_ordinal_to_read < 12 {
6223 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6224 _next_ordinal_to_read += 1;
6225 next_offset += envelope_size;
6226 }
6227
6228 let next_out_of_line = decoder.next_out_of_line();
6229 let handles_before = decoder.remaining_handles();
6230 if let Some((inlined, num_bytes, num_handles)) =
6231 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6232 {
6233 let member_inline_size = <fidl::encoding::Vector<
6234 fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
6235 64,
6236 > as fidl::encoding::TypeMarker>::inline_size(
6237 decoder.context
6238 );
6239 if inlined != (member_inline_size <= 4) {
6240 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6241 }
6242 let inner_offset;
6243 let mut inner_depth = depth.clone();
6244 if inlined {
6245 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6246 inner_offset = next_offset;
6247 } else {
6248 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6249 inner_depth.increment()?;
6250 }
6251 let val_ref =
6252 self.signal_processing_elements.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D));
6253 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6255 {
6256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6257 }
6258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6260 }
6261 }
6262
6263 next_offset += envelope_size;
6264 _next_ordinal_to_read += 1;
6265 if next_offset >= end_offset {
6266 return Ok(());
6267 }
6268
6269 while _next_ordinal_to_read < 13 {
6271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6272 _next_ordinal_to_read += 1;
6273 next_offset += envelope_size;
6274 }
6275
6276 let next_out_of_line = decoder.next_out_of_line();
6277 let handles_before = decoder.remaining_handles();
6278 if let Some((inlined, num_bytes, num_handles)) =
6279 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6280 {
6281 let member_inline_size = <fidl::encoding::Vector<
6282 fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
6283 64,
6284 > as fidl::encoding::TypeMarker>::inline_size(
6285 decoder.context
6286 );
6287 if inlined != (member_inline_size <= 4) {
6288 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6289 }
6290 let inner_offset;
6291 let mut inner_depth = depth.clone();
6292 if inlined {
6293 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6294 inner_offset = next_offset;
6295 } else {
6296 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6297 inner_depth.increment()?;
6298 }
6299 let val_ref =
6300 self.signal_processing_topologies.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D));
6301 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6302 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6303 {
6304 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6305 }
6306 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6307 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6308 }
6309 }
6310
6311 next_offset += envelope_size;
6312
6313 while next_offset < end_offset {
6315 _next_ordinal_to_read += 1;
6316 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6317 next_offset += envelope_size;
6318 }
6319
6320 Ok(())
6321 }
6322 }
6323
6324 impl ObserverWatchPlugStateResponse {
6325 #[inline(always)]
6326 fn max_ordinal_present(&self) -> u64 {
6327 if let Some(_) = self.plug_time {
6328 return 2;
6329 }
6330 if let Some(_) = self.state {
6331 return 1;
6332 }
6333 0
6334 }
6335 }
6336
6337 impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateResponse {
6338 type Borrowed<'a> = &'a Self;
6339 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6340 value
6341 }
6342 }
6343
6344 unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateResponse {
6345 type Owned = Self;
6346
6347 #[inline(always)]
6348 fn inline_align(_context: fidl::encoding::Context) -> usize {
6349 8
6350 }
6351
6352 #[inline(always)]
6353 fn inline_size(_context: fidl::encoding::Context) -> usize {
6354 16
6355 }
6356 }
6357
6358 unsafe impl<D: fidl::encoding::ResourceDialect>
6359 fidl::encoding::Encode<ObserverWatchPlugStateResponse, D>
6360 for &ObserverWatchPlugStateResponse
6361 {
6362 unsafe fn encode(
6363 self,
6364 encoder: &mut fidl::encoding::Encoder<'_, D>,
6365 offset: usize,
6366 mut depth: fidl::encoding::Depth,
6367 ) -> fidl::Result<()> {
6368 encoder.debug_check_bounds::<ObserverWatchPlugStateResponse>(offset);
6369 let max_ordinal: u64 = self.max_ordinal_present();
6371 encoder.write_num(max_ordinal, offset);
6372 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6373 if max_ordinal == 0 {
6375 return Ok(());
6376 }
6377 depth.increment()?;
6378 let envelope_size = 8;
6379 let bytes_len = max_ordinal as usize * envelope_size;
6380 #[allow(unused_variables)]
6381 let offset = encoder.out_of_line_offset(bytes_len);
6382 let mut _prev_end_offset: usize = 0;
6383 if 1 > max_ordinal {
6384 return Ok(());
6385 }
6386
6387 let cur_offset: usize = (1 - 1) * envelope_size;
6390
6391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6393
6394 fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6399 self.state.as_ref().map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6400 encoder,
6401 offset + cur_offset,
6402 depth,
6403 )?;
6404
6405 _prev_end_offset = cur_offset + envelope_size;
6406 if 2 > max_ordinal {
6407 return Ok(());
6408 }
6409
6410 let cur_offset: usize = (2 - 1) * envelope_size;
6413
6414 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6416
6417 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6422 self.plug_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6423 encoder,
6424 offset + cur_offset,
6425 depth,
6426 )?;
6427
6428 _prev_end_offset = cur_offset + envelope_size;
6429
6430 Ok(())
6431 }
6432 }
6433
6434 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6435 for ObserverWatchPlugStateResponse
6436 {
6437 #[inline(always)]
6438 fn new_empty() -> Self {
6439 Self::default()
6440 }
6441
6442 unsafe fn decode(
6443 &mut self,
6444 decoder: &mut fidl::encoding::Decoder<'_, D>,
6445 offset: usize,
6446 mut depth: fidl::encoding::Depth,
6447 ) -> fidl::Result<()> {
6448 decoder.debug_check_bounds::<Self>(offset);
6449 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6450 None => return Err(fidl::Error::NotNullable),
6451 Some(len) => len,
6452 };
6453 if len == 0 {
6455 return Ok(());
6456 };
6457 depth.increment()?;
6458 let envelope_size = 8;
6459 let bytes_len = len * envelope_size;
6460 let offset = decoder.out_of_line_offset(bytes_len)?;
6461 let mut _next_ordinal_to_read = 0;
6463 let mut next_offset = offset;
6464 let end_offset = offset + bytes_len;
6465 _next_ordinal_to_read += 1;
6466 if next_offset >= end_offset {
6467 return Ok(());
6468 }
6469
6470 while _next_ordinal_to_read < 1 {
6472 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6473 _next_ordinal_to_read += 1;
6474 next_offset += envelope_size;
6475 }
6476
6477 let next_out_of_line = decoder.next_out_of_line();
6478 let handles_before = decoder.remaining_handles();
6479 if let Some((inlined, num_bytes, num_handles)) =
6480 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6481 {
6482 let member_inline_size =
6483 <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6484 if inlined != (member_inline_size <= 4) {
6485 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6486 }
6487 let inner_offset;
6488 let mut inner_depth = depth.clone();
6489 if inlined {
6490 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6491 inner_offset = next_offset;
6492 } else {
6493 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6494 inner_depth.increment()?;
6495 }
6496 let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6497 fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6498 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6499 {
6500 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6501 }
6502 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6503 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6504 }
6505 }
6506
6507 next_offset += envelope_size;
6508 _next_ordinal_to_read += 1;
6509 if next_offset >= end_offset {
6510 return Ok(());
6511 }
6512
6513 while _next_ordinal_to_read < 2 {
6515 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6516 _next_ordinal_to_read += 1;
6517 next_offset += envelope_size;
6518 }
6519
6520 let next_out_of_line = decoder.next_out_of_line();
6521 let handles_before = decoder.remaining_handles();
6522 if let Some((inlined, num_bytes, num_handles)) =
6523 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6524 {
6525 let member_inline_size =
6526 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6527 if inlined != (member_inline_size <= 4) {
6528 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6529 }
6530 let inner_offset;
6531 let mut inner_depth = depth.clone();
6532 if inlined {
6533 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6534 inner_offset = next_offset;
6535 } else {
6536 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6537 inner_depth.increment()?;
6538 }
6539 let val_ref = self.plug_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
6540 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6541 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6542 {
6543 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6544 }
6545 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6546 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6547 }
6548 }
6549
6550 next_offset += envelope_size;
6551
6552 while next_offset < end_offset {
6554 _next_ordinal_to_read += 1;
6555 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6556 next_offset += envelope_size;
6557 }
6558
6559 Ok(())
6560 }
6561 }
6562
6563 impl PcmFormatSet {
6564 #[inline(always)]
6565 fn max_ordinal_present(&self) -> u64 {
6566 if let Some(_) = self.frame_rates {
6567 return 3;
6568 }
6569 if let Some(_) = self.sample_types {
6570 return 2;
6571 }
6572 if let Some(_) = self.channel_sets {
6573 return 1;
6574 }
6575 0
6576 }
6577 }
6578
6579 impl fidl::encoding::ValueTypeMarker for PcmFormatSet {
6580 type Borrowed<'a> = &'a Self;
6581 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6582 value
6583 }
6584 }
6585
6586 unsafe impl fidl::encoding::TypeMarker for PcmFormatSet {
6587 type Owned = Self;
6588
6589 #[inline(always)]
6590 fn inline_align(_context: fidl::encoding::Context) -> usize {
6591 8
6592 }
6593
6594 #[inline(always)]
6595 fn inline_size(_context: fidl::encoding::Context) -> usize {
6596 16
6597 }
6598 }
6599
6600 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormatSet, D>
6601 for &PcmFormatSet
6602 {
6603 unsafe fn encode(
6604 self,
6605 encoder: &mut fidl::encoding::Encoder<'_, D>,
6606 offset: usize,
6607 mut depth: fidl::encoding::Depth,
6608 ) -> fidl::Result<()> {
6609 encoder.debug_check_bounds::<PcmFormatSet>(offset);
6610 let max_ordinal: u64 = self.max_ordinal_present();
6612 encoder.write_num(max_ordinal, offset);
6613 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6614 if max_ordinal == 0 {
6616 return Ok(());
6617 }
6618 depth.increment()?;
6619 let envelope_size = 8;
6620 let bytes_len = max_ordinal as usize * envelope_size;
6621 #[allow(unused_variables)]
6622 let offset = encoder.out_of_line_offset(bytes_len);
6623 let mut _prev_end_offset: usize = 0;
6624 if 1 > max_ordinal {
6625 return Ok(());
6626 }
6627
6628 let cur_offset: usize = (1 - 1) * envelope_size;
6631
6632 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6634
6635 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelSet, 64>, D>(
6640 self.channel_sets.as_ref().map(<fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6641 encoder, offset + cur_offset, depth
6642 )?;
6643
6644 _prev_end_offset = cur_offset + envelope_size;
6645 if 2 > max_ordinal {
6646 return Ok(());
6647 }
6648
6649 let cur_offset: usize = (2 - 1) * envelope_size;
6652
6653 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6655
6656 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D>(
6661 self.sample_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6662 encoder, offset + cur_offset, depth
6663 )?;
6664
6665 _prev_end_offset = cur_offset + envelope_size;
6666 if 3 > max_ordinal {
6667 return Ok(());
6668 }
6669
6670 let cur_offset: usize = (3 - 1) * envelope_size;
6673
6674 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6676
6677 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u32, 64>, D>(
6682 self.frame_rates.as_ref().map(
6683 <fidl::encoding::Vector<u32, 64> as fidl::encoding::ValueTypeMarker>::borrow,
6684 ),
6685 encoder,
6686 offset + cur_offset,
6687 depth,
6688 )?;
6689
6690 _prev_end_offset = cur_offset + envelope_size;
6691
6692 Ok(())
6693 }
6694 }
6695
6696 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormatSet {
6697 #[inline(always)]
6698 fn new_empty() -> Self {
6699 Self::default()
6700 }
6701
6702 unsafe fn decode(
6703 &mut self,
6704 decoder: &mut fidl::encoding::Decoder<'_, D>,
6705 offset: usize,
6706 mut depth: fidl::encoding::Depth,
6707 ) -> fidl::Result<()> {
6708 decoder.debug_check_bounds::<Self>(offset);
6709 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6710 None => return Err(fidl::Error::NotNullable),
6711 Some(len) => len,
6712 };
6713 if len == 0 {
6715 return Ok(());
6716 };
6717 depth.increment()?;
6718 let envelope_size = 8;
6719 let bytes_len = len * envelope_size;
6720 let offset = decoder.out_of_line_offset(bytes_len)?;
6721 let mut _next_ordinal_to_read = 0;
6723 let mut next_offset = offset;
6724 let end_offset = offset + bytes_len;
6725 _next_ordinal_to_read += 1;
6726 if next_offset >= end_offset {
6727 return Ok(());
6728 }
6729
6730 while _next_ordinal_to_read < 1 {
6732 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6733 _next_ordinal_to_read += 1;
6734 next_offset += envelope_size;
6735 }
6736
6737 let next_out_of_line = decoder.next_out_of_line();
6738 let handles_before = decoder.remaining_handles();
6739 if let Some((inlined, num_bytes, num_handles)) =
6740 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6741 {
6742 let member_inline_size = <fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6743 if inlined != (member_inline_size <= 4) {
6744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6745 }
6746 let inner_offset;
6747 let mut inner_depth = depth.clone();
6748 if inlined {
6749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6750 inner_offset = next_offset;
6751 } else {
6752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6753 inner_depth.increment()?;
6754 }
6755 let val_ref = self.channel_sets.get_or_insert_with(
6756 || fidl::new_empty!(fidl::encoding::Vector<ChannelSet, 64>, D),
6757 );
6758 fidl::decode!(fidl::encoding::Vector<ChannelSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6760 {
6761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6762 }
6763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6765 }
6766 }
6767
6768 next_offset += envelope_size;
6769 _next_ordinal_to_read += 1;
6770 if next_offset >= end_offset {
6771 return Ok(());
6772 }
6773
6774 while _next_ordinal_to_read < 2 {
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<
6787 fidl_fuchsia_audio__common::SampleType,
6788 32,
6789 > as fidl::encoding::TypeMarker>::inline_size(
6790 decoder.context
6791 );
6792 if inlined != (member_inline_size <= 4) {
6793 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6794 }
6795 let inner_offset;
6796 let mut inner_depth = depth.clone();
6797 if inlined {
6798 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6799 inner_offset = next_offset;
6800 } else {
6801 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6802 inner_depth.increment()?;
6803 }
6804 let val_ref =
6805 self.sample_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D));
6806 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6807 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6808 {
6809 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6810 }
6811 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6812 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6813 }
6814 }
6815
6816 next_offset += envelope_size;
6817 _next_ordinal_to_read += 1;
6818 if next_offset >= end_offset {
6819 return Ok(());
6820 }
6821
6822 while _next_ordinal_to_read < 3 {
6824 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6825 _next_ordinal_to_read += 1;
6826 next_offset += envelope_size;
6827 }
6828
6829 let next_out_of_line = decoder.next_out_of_line();
6830 let handles_before = decoder.remaining_handles();
6831 if let Some((inlined, num_bytes, num_handles)) =
6832 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6833 {
6834 let member_inline_size =
6835 <fidl::encoding::Vector<u32, 64> as fidl::encoding::TypeMarker>::inline_size(
6836 decoder.context,
6837 );
6838 if inlined != (member_inline_size <= 4) {
6839 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6840 }
6841 let inner_offset;
6842 let mut inner_depth = depth.clone();
6843 if inlined {
6844 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6845 inner_offset = next_offset;
6846 } else {
6847 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6848 inner_depth.increment()?;
6849 }
6850 let val_ref = self
6851 .frame_rates
6852 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u32, 64>, D));
6853 fidl::decode!(fidl::encoding::Vector<u32, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6854 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6855 {
6856 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6857 }
6858 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6859 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6860 }
6861 }
6862
6863 next_offset += envelope_size;
6864
6865 while next_offset < end_offset {
6867 _next_ordinal_to_read += 1;
6868 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6869 next_offset += envelope_size;
6870 }
6871
6872 Ok(())
6873 }
6874 }
6875
6876 impl ProviderAddDeviceResponse {
6877 #[inline(always)]
6878 fn max_ordinal_present(&self) -> u64 {
6879 0
6880 }
6881 }
6882
6883 impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceResponse {
6884 type Borrowed<'a> = &'a Self;
6885 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6886 value
6887 }
6888 }
6889
6890 unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceResponse {
6891 type Owned = Self;
6892
6893 #[inline(always)]
6894 fn inline_align(_context: fidl::encoding::Context) -> usize {
6895 8
6896 }
6897
6898 #[inline(always)]
6899 fn inline_size(_context: fidl::encoding::Context) -> usize {
6900 16
6901 }
6902 }
6903
6904 unsafe impl<D: fidl::encoding::ResourceDialect>
6905 fidl::encoding::Encode<ProviderAddDeviceResponse, D> for &ProviderAddDeviceResponse
6906 {
6907 unsafe fn encode(
6908 self,
6909 encoder: &mut fidl::encoding::Encoder<'_, D>,
6910 offset: usize,
6911 mut depth: fidl::encoding::Depth,
6912 ) -> fidl::Result<()> {
6913 encoder.debug_check_bounds::<ProviderAddDeviceResponse>(offset);
6914 let max_ordinal: u64 = self.max_ordinal_present();
6916 encoder.write_num(max_ordinal, offset);
6917 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6918 if max_ordinal == 0 {
6920 return Ok(());
6921 }
6922 depth.increment()?;
6923 let envelope_size = 8;
6924 let bytes_len = max_ordinal as usize * envelope_size;
6925 #[allow(unused_variables)]
6926 let offset = encoder.out_of_line_offset(bytes_len);
6927 let mut _prev_end_offset: usize = 0;
6928
6929 Ok(())
6930 }
6931 }
6932
6933 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6934 for ProviderAddDeviceResponse
6935 {
6936 #[inline(always)]
6937 fn new_empty() -> Self {
6938 Self::default()
6939 }
6940
6941 unsafe fn decode(
6942 &mut self,
6943 decoder: &mut fidl::encoding::Decoder<'_, D>,
6944 offset: usize,
6945 mut depth: fidl::encoding::Depth,
6946 ) -> fidl::Result<()> {
6947 decoder.debug_check_bounds::<Self>(offset);
6948 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6949 None => return Err(fidl::Error::NotNullable),
6950 Some(len) => len,
6951 };
6952 if len == 0 {
6954 return Ok(());
6955 };
6956 depth.increment()?;
6957 let envelope_size = 8;
6958 let bytes_len = len * envelope_size;
6959 let offset = decoder.out_of_line_offset(bytes_len)?;
6960 let mut _next_ordinal_to_read = 0;
6962 let mut next_offset = offset;
6963 let end_offset = offset + bytes_len;
6964
6965 while next_offset < end_offset {
6967 _next_ordinal_to_read += 1;
6968 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6969 next_offset += envelope_size;
6970 }
6971
6972 Ok(())
6973 }
6974 }
6975
6976 impl RegistryCreateObserverResponse {
6977 #[inline(always)]
6978 fn max_ordinal_present(&self) -> u64 {
6979 0
6980 }
6981 }
6982
6983 impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverResponse {
6984 type Borrowed<'a> = &'a Self;
6985 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6986 value
6987 }
6988 }
6989
6990 unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverResponse {
6991 type Owned = Self;
6992
6993 #[inline(always)]
6994 fn inline_align(_context: fidl::encoding::Context) -> usize {
6995 8
6996 }
6997
6998 #[inline(always)]
6999 fn inline_size(_context: fidl::encoding::Context) -> usize {
7000 16
7001 }
7002 }
7003
7004 unsafe impl<D: fidl::encoding::ResourceDialect>
7005 fidl::encoding::Encode<RegistryCreateObserverResponse, D>
7006 for &RegistryCreateObserverResponse
7007 {
7008 unsafe fn encode(
7009 self,
7010 encoder: &mut fidl::encoding::Encoder<'_, D>,
7011 offset: usize,
7012 mut depth: fidl::encoding::Depth,
7013 ) -> fidl::Result<()> {
7014 encoder.debug_check_bounds::<RegistryCreateObserverResponse>(offset);
7015 let max_ordinal: u64 = self.max_ordinal_present();
7017 encoder.write_num(max_ordinal, offset);
7018 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7019 if max_ordinal == 0 {
7021 return Ok(());
7022 }
7023 depth.increment()?;
7024 let envelope_size = 8;
7025 let bytes_len = max_ordinal as usize * envelope_size;
7026 #[allow(unused_variables)]
7027 let offset = encoder.out_of_line_offset(bytes_len);
7028 let mut _prev_end_offset: usize = 0;
7029
7030 Ok(())
7031 }
7032 }
7033
7034 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7035 for RegistryCreateObserverResponse
7036 {
7037 #[inline(always)]
7038 fn new_empty() -> Self {
7039 Self::default()
7040 }
7041
7042 unsafe fn decode(
7043 &mut self,
7044 decoder: &mut fidl::encoding::Decoder<'_, D>,
7045 offset: usize,
7046 mut depth: fidl::encoding::Depth,
7047 ) -> fidl::Result<()> {
7048 decoder.debug_check_bounds::<Self>(offset);
7049 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7050 None => return Err(fidl::Error::NotNullable),
7051 Some(len) => len,
7052 };
7053 if len == 0 {
7055 return Ok(());
7056 };
7057 depth.increment()?;
7058 let envelope_size = 8;
7059 let bytes_len = len * envelope_size;
7060 let offset = decoder.out_of_line_offset(bytes_len)?;
7061 let mut _next_ordinal_to_read = 0;
7063 let mut next_offset = offset;
7064 let end_offset = offset + bytes_len;
7065
7066 while next_offset < end_offset {
7068 _next_ordinal_to_read += 1;
7069 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7070 next_offset += envelope_size;
7071 }
7072
7073 Ok(())
7074 }
7075 }
7076
7077 impl RegistryWatchDeviceRemovedResponse {
7078 #[inline(always)]
7079 fn max_ordinal_present(&self) -> u64 {
7080 if let Some(_) = self.token_id {
7081 return 1;
7082 }
7083 0
7084 }
7085 }
7086
7087 impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedResponse {
7088 type Borrowed<'a> = &'a Self;
7089 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7090 value
7091 }
7092 }
7093
7094 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedResponse {
7095 type Owned = Self;
7096
7097 #[inline(always)]
7098 fn inline_align(_context: fidl::encoding::Context) -> usize {
7099 8
7100 }
7101
7102 #[inline(always)]
7103 fn inline_size(_context: fidl::encoding::Context) -> usize {
7104 16
7105 }
7106 }
7107
7108 unsafe impl<D: fidl::encoding::ResourceDialect>
7109 fidl::encoding::Encode<RegistryWatchDeviceRemovedResponse, D>
7110 for &RegistryWatchDeviceRemovedResponse
7111 {
7112 unsafe fn encode(
7113 self,
7114 encoder: &mut fidl::encoding::Encoder<'_, D>,
7115 offset: usize,
7116 mut depth: fidl::encoding::Depth,
7117 ) -> fidl::Result<()> {
7118 encoder.debug_check_bounds::<RegistryWatchDeviceRemovedResponse>(offset);
7119 let max_ordinal: u64 = self.max_ordinal_present();
7121 encoder.write_num(max_ordinal, offset);
7122 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7123 if max_ordinal == 0 {
7125 return Ok(());
7126 }
7127 depth.increment()?;
7128 let envelope_size = 8;
7129 let bytes_len = max_ordinal as usize * envelope_size;
7130 #[allow(unused_variables)]
7131 let offset = encoder.out_of_line_offset(bytes_len);
7132 let mut _prev_end_offset: usize = 0;
7133 if 1 > max_ordinal {
7134 return Ok(());
7135 }
7136
7137 let cur_offset: usize = (1 - 1) * envelope_size;
7140
7141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7143
7144 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7149 self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7150 encoder,
7151 offset + cur_offset,
7152 depth,
7153 )?;
7154
7155 _prev_end_offset = cur_offset + envelope_size;
7156
7157 Ok(())
7158 }
7159 }
7160
7161 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7162 for RegistryWatchDeviceRemovedResponse
7163 {
7164 #[inline(always)]
7165 fn new_empty() -> Self {
7166 Self::default()
7167 }
7168
7169 unsafe fn decode(
7170 &mut self,
7171 decoder: &mut fidl::encoding::Decoder<'_, D>,
7172 offset: usize,
7173 mut depth: fidl::encoding::Depth,
7174 ) -> fidl::Result<()> {
7175 decoder.debug_check_bounds::<Self>(offset);
7176 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7177 None => return Err(fidl::Error::NotNullable),
7178 Some(len) => len,
7179 };
7180 if len == 0 {
7182 return Ok(());
7183 };
7184 depth.increment()?;
7185 let envelope_size = 8;
7186 let bytes_len = len * envelope_size;
7187 let offset = decoder.out_of_line_offset(bytes_len)?;
7188 let mut _next_ordinal_to_read = 0;
7190 let mut next_offset = offset;
7191 let end_offset = offset + bytes_len;
7192 _next_ordinal_to_read += 1;
7193 if next_offset >= end_offset {
7194 return Ok(());
7195 }
7196
7197 while _next_ordinal_to_read < 1 {
7199 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7200 _next_ordinal_to_read += 1;
7201 next_offset += envelope_size;
7202 }
7203
7204 let next_out_of_line = decoder.next_out_of_line();
7205 let handles_before = decoder.remaining_handles();
7206 if let Some((inlined, num_bytes, num_handles)) =
7207 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7208 {
7209 let member_inline_size =
7210 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7211 if inlined != (member_inline_size <= 4) {
7212 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7213 }
7214 let inner_offset;
7215 let mut inner_depth = depth.clone();
7216 if inlined {
7217 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7218 inner_offset = next_offset;
7219 } else {
7220 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7221 inner_depth.increment()?;
7222 }
7223 let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7224 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7225 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7226 {
7227 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7228 }
7229 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7230 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7231 }
7232 }
7233
7234 next_offset += envelope_size;
7235
7236 while next_offset < end_offset {
7238 _next_ordinal_to_read += 1;
7239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7240 next_offset += envelope_size;
7241 }
7242
7243 Ok(())
7244 }
7245 }
7246
7247 impl RegistryWatchDevicesAddedResponse {
7248 #[inline(always)]
7249 fn max_ordinal_present(&self) -> u64 {
7250 if let Some(_) = self.devices {
7251 return 1;
7252 }
7253 0
7254 }
7255 }
7256
7257 impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedResponse {
7258 type Borrowed<'a> = &'a Self;
7259 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7260 value
7261 }
7262 }
7263
7264 unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedResponse {
7265 type Owned = Self;
7266
7267 #[inline(always)]
7268 fn inline_align(_context: fidl::encoding::Context) -> usize {
7269 8
7270 }
7271
7272 #[inline(always)]
7273 fn inline_size(_context: fidl::encoding::Context) -> usize {
7274 16
7275 }
7276 }
7277
7278 unsafe impl<D: fidl::encoding::ResourceDialect>
7279 fidl::encoding::Encode<RegistryWatchDevicesAddedResponse, D>
7280 for &RegistryWatchDevicesAddedResponse
7281 {
7282 unsafe fn encode(
7283 self,
7284 encoder: &mut fidl::encoding::Encoder<'_, D>,
7285 offset: usize,
7286 mut depth: fidl::encoding::Depth,
7287 ) -> fidl::Result<()> {
7288 encoder.debug_check_bounds::<RegistryWatchDevicesAddedResponse>(offset);
7289 let max_ordinal: u64 = self.max_ordinal_present();
7291 encoder.write_num(max_ordinal, offset);
7292 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7293 if max_ordinal == 0 {
7295 return Ok(());
7296 }
7297 depth.increment()?;
7298 let envelope_size = 8;
7299 let bytes_len = max_ordinal as usize * envelope_size;
7300 #[allow(unused_variables)]
7301 let offset = encoder.out_of_line_offset(bytes_len);
7302 let mut _prev_end_offset: usize = 0;
7303 if 1 > max_ordinal {
7304 return Ok(());
7305 }
7306
7307 let cur_offset: usize = (1 - 1) * envelope_size;
7310
7311 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7313
7314 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Info, 256>, D>(
7319 self.devices.as_ref().map(
7320 <fidl::encoding::Vector<Info, 256> as fidl::encoding::ValueTypeMarker>::borrow,
7321 ),
7322 encoder,
7323 offset + cur_offset,
7324 depth,
7325 )?;
7326
7327 _prev_end_offset = cur_offset + envelope_size;
7328
7329 Ok(())
7330 }
7331 }
7332
7333 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7334 for RegistryWatchDevicesAddedResponse
7335 {
7336 #[inline(always)]
7337 fn new_empty() -> Self {
7338 Self::default()
7339 }
7340
7341 unsafe fn decode(
7342 &mut self,
7343 decoder: &mut fidl::encoding::Decoder<'_, D>,
7344 offset: usize,
7345 mut depth: fidl::encoding::Depth,
7346 ) -> fidl::Result<()> {
7347 decoder.debug_check_bounds::<Self>(offset);
7348 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7349 None => return Err(fidl::Error::NotNullable),
7350 Some(len) => len,
7351 };
7352 if len == 0 {
7354 return Ok(());
7355 };
7356 depth.increment()?;
7357 let envelope_size = 8;
7358 let bytes_len = len * envelope_size;
7359 let offset = decoder.out_of_line_offset(bytes_len)?;
7360 let mut _next_ordinal_to_read = 0;
7362 let mut next_offset = offset;
7363 let end_offset = offset + bytes_len;
7364 _next_ordinal_to_read += 1;
7365 if next_offset >= end_offset {
7366 return Ok(());
7367 }
7368
7369 while _next_ordinal_to_read < 1 {
7371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7372 _next_ordinal_to_read += 1;
7373 next_offset += envelope_size;
7374 }
7375
7376 let next_out_of_line = decoder.next_out_of_line();
7377 let handles_before = decoder.remaining_handles();
7378 if let Some((inlined, num_bytes, num_handles)) =
7379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7380 {
7381 let member_inline_size =
7382 <fidl::encoding::Vector<Info, 256> as fidl::encoding::TypeMarker>::inline_size(
7383 decoder.context,
7384 );
7385 if inlined != (member_inline_size <= 4) {
7386 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7387 }
7388 let inner_offset;
7389 let mut inner_depth = depth.clone();
7390 if inlined {
7391 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7392 inner_offset = next_offset;
7393 } else {
7394 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7395 inner_depth.increment()?;
7396 }
7397 let val_ref = self
7398 .devices
7399 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Info, 256>, D));
7400 fidl::decode!(fidl::encoding::Vector<Info, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
7401 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7402 {
7403 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7404 }
7405 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7406 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7407 }
7408 }
7409
7410 next_offset += envelope_size;
7411
7412 while next_offset < end_offset {
7414 _next_ordinal_to_read += 1;
7415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7416 next_offset += envelope_size;
7417 }
7418
7419 Ok(())
7420 }
7421 }
7422
7423 impl RingBufferOptions {
7424 #[inline(always)]
7425 fn max_ordinal_present(&self) -> u64 {
7426 if let Some(_) = self.ring_buffer_min_bytes {
7427 return 2;
7428 }
7429 if let Some(_) = self.format {
7430 return 1;
7431 }
7432 0
7433 }
7434 }
7435
7436 impl fidl::encoding::ValueTypeMarker for RingBufferOptions {
7437 type Borrowed<'a> = &'a Self;
7438 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7439 value
7440 }
7441 }
7442
7443 unsafe impl fidl::encoding::TypeMarker for RingBufferOptions {
7444 type Owned = Self;
7445
7446 #[inline(always)]
7447 fn inline_align(_context: fidl::encoding::Context) -> usize {
7448 8
7449 }
7450
7451 #[inline(always)]
7452 fn inline_size(_context: fidl::encoding::Context) -> usize {
7453 16
7454 }
7455 }
7456
7457 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferOptions, D>
7458 for &RingBufferOptions
7459 {
7460 unsafe fn encode(
7461 self,
7462 encoder: &mut fidl::encoding::Encoder<'_, D>,
7463 offset: usize,
7464 mut depth: fidl::encoding::Depth,
7465 ) -> fidl::Result<()> {
7466 encoder.debug_check_bounds::<RingBufferOptions>(offset);
7467 let max_ordinal: u64 = self.max_ordinal_present();
7469 encoder.write_num(max_ordinal, offset);
7470 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7471 if max_ordinal == 0 {
7473 return Ok(());
7474 }
7475 depth.increment()?;
7476 let envelope_size = 8;
7477 let bytes_len = max_ordinal as usize * envelope_size;
7478 #[allow(unused_variables)]
7479 let offset = encoder.out_of_line_offset(bytes_len);
7480 let mut _prev_end_offset: usize = 0;
7481 if 1 > max_ordinal {
7482 return Ok(());
7483 }
7484
7485 let cur_offset: usize = (1 - 1) * envelope_size;
7488
7489 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7491
7492 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_audio__common::Format, D>(
7497 self.format.as_ref().map(
7498 <fidl_fuchsia_audio__common::Format as fidl::encoding::ValueTypeMarker>::borrow,
7499 ),
7500 encoder,
7501 offset + cur_offset,
7502 depth,
7503 )?;
7504
7505 _prev_end_offset = cur_offset + envelope_size;
7506 if 2 > max_ordinal {
7507 return Ok(());
7508 }
7509
7510 let cur_offset: usize = (2 - 1) * envelope_size;
7513
7514 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7516
7517 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7522 self.ring_buffer_min_bytes
7523 .as_ref()
7524 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7525 encoder,
7526 offset + cur_offset,
7527 depth,
7528 )?;
7529
7530 _prev_end_offset = cur_offset + envelope_size;
7531
7532 Ok(())
7533 }
7534 }
7535
7536 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferOptions {
7537 #[inline(always)]
7538 fn new_empty() -> Self {
7539 Self::default()
7540 }
7541
7542 unsafe fn decode(
7543 &mut self,
7544 decoder: &mut fidl::encoding::Decoder<'_, D>,
7545 offset: usize,
7546 mut depth: fidl::encoding::Depth,
7547 ) -> fidl::Result<()> {
7548 decoder.debug_check_bounds::<Self>(offset);
7549 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7550 None => return Err(fidl::Error::NotNullable),
7551 Some(len) => len,
7552 };
7553 if len == 0 {
7555 return Ok(());
7556 };
7557 depth.increment()?;
7558 let envelope_size = 8;
7559 let bytes_len = len * envelope_size;
7560 let offset = decoder.out_of_line_offset(bytes_len)?;
7561 let mut _next_ordinal_to_read = 0;
7563 let mut next_offset = offset;
7564 let end_offset = offset + bytes_len;
7565 _next_ordinal_to_read += 1;
7566 if next_offset >= end_offset {
7567 return Ok(());
7568 }
7569
7570 while _next_ordinal_to_read < 1 {
7572 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7573 _next_ordinal_to_read += 1;
7574 next_offset += envelope_size;
7575 }
7576
7577 let next_out_of_line = decoder.next_out_of_line();
7578 let handles_before = decoder.remaining_handles();
7579 if let Some((inlined, num_bytes, num_handles)) =
7580 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7581 {
7582 let member_inline_size =
7583 <fidl_fuchsia_audio__common::Format as fidl::encoding::TypeMarker>::inline_size(
7584 decoder.context,
7585 );
7586 if inlined != (member_inline_size <= 4) {
7587 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7588 }
7589 let inner_offset;
7590 let mut inner_depth = depth.clone();
7591 if inlined {
7592 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7593 inner_offset = next_offset;
7594 } else {
7595 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7596 inner_depth.increment()?;
7597 }
7598 let val_ref = self
7599 .format
7600 .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_audio__common::Format, D));
7601 fidl::decode!(
7602 fidl_fuchsia_audio__common::Format,
7603 D,
7604 val_ref,
7605 decoder,
7606 inner_offset,
7607 inner_depth
7608 )?;
7609 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7610 {
7611 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7612 }
7613 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7614 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7615 }
7616 }
7617
7618 next_offset += envelope_size;
7619 _next_ordinal_to_read += 1;
7620 if next_offset >= end_offset {
7621 return Ok(());
7622 }
7623
7624 while _next_ordinal_to_read < 2 {
7626 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7627 _next_ordinal_to_read += 1;
7628 next_offset += envelope_size;
7629 }
7630
7631 let next_out_of_line = decoder.next_out_of_line();
7632 let handles_before = decoder.remaining_handles();
7633 if let Some((inlined, num_bytes, num_handles)) =
7634 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7635 {
7636 let member_inline_size =
7637 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7638 if inlined != (member_inline_size <= 4) {
7639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7640 }
7641 let inner_offset;
7642 let mut inner_depth = depth.clone();
7643 if inlined {
7644 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7645 inner_offset = next_offset;
7646 } else {
7647 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7648 inner_depth.increment()?;
7649 }
7650 let val_ref =
7651 self.ring_buffer_min_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
7652 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
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
7664 while next_offset < end_offset {
7666 _next_ordinal_to_read += 1;
7667 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7668 next_offset += envelope_size;
7669 }
7670
7671 Ok(())
7672 }
7673 }
7674
7675 impl RingBufferProperties {
7676 #[inline(always)]
7677 fn max_ordinal_present(&self) -> u64 {
7678 if let Some(_) = self.turn_on_delay {
7679 return 2;
7680 }
7681 if let Some(_) = self.valid_bits_per_sample {
7682 return 1;
7683 }
7684 0
7685 }
7686 }
7687
7688 impl fidl::encoding::ValueTypeMarker for RingBufferProperties {
7689 type Borrowed<'a> = &'a Self;
7690 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7691 value
7692 }
7693 }
7694
7695 unsafe impl fidl::encoding::TypeMarker for RingBufferProperties {
7696 type Owned = Self;
7697
7698 #[inline(always)]
7699 fn inline_align(_context: fidl::encoding::Context) -> usize {
7700 8
7701 }
7702
7703 #[inline(always)]
7704 fn inline_size(_context: fidl::encoding::Context) -> usize {
7705 16
7706 }
7707 }
7708
7709 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferProperties, D>
7710 for &RingBufferProperties
7711 {
7712 unsafe fn encode(
7713 self,
7714 encoder: &mut fidl::encoding::Encoder<'_, D>,
7715 offset: usize,
7716 mut depth: fidl::encoding::Depth,
7717 ) -> fidl::Result<()> {
7718 encoder.debug_check_bounds::<RingBufferProperties>(offset);
7719 let max_ordinal: u64 = self.max_ordinal_present();
7721 encoder.write_num(max_ordinal, offset);
7722 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7723 if max_ordinal == 0 {
7725 return Ok(());
7726 }
7727 depth.increment()?;
7728 let envelope_size = 8;
7729 let bytes_len = max_ordinal as usize * envelope_size;
7730 #[allow(unused_variables)]
7731 let offset = encoder.out_of_line_offset(bytes_len);
7732 let mut _prev_end_offset: usize = 0;
7733 if 1 > max_ordinal {
7734 return Ok(());
7735 }
7736
7737 let cur_offset: usize = (1 - 1) * envelope_size;
7740
7741 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7743
7744 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7749 self.valid_bits_per_sample
7750 .as_ref()
7751 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7752 encoder,
7753 offset + cur_offset,
7754 depth,
7755 )?;
7756
7757 _prev_end_offset = cur_offset + envelope_size;
7758 if 2 > max_ordinal {
7759 return Ok(());
7760 }
7761
7762 let cur_offset: usize = (2 - 1) * envelope_size;
7765
7766 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7768
7769 fidl::encoding::encode_in_envelope_optional::<i64, D>(
7774 self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7775 encoder,
7776 offset + cur_offset,
7777 depth,
7778 )?;
7779
7780 _prev_end_offset = cur_offset + envelope_size;
7781
7782 Ok(())
7783 }
7784 }
7785
7786 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferProperties {
7787 #[inline(always)]
7788 fn new_empty() -> Self {
7789 Self::default()
7790 }
7791
7792 unsafe fn decode(
7793 &mut self,
7794 decoder: &mut fidl::encoding::Decoder<'_, D>,
7795 offset: usize,
7796 mut depth: fidl::encoding::Depth,
7797 ) -> fidl::Result<()> {
7798 decoder.debug_check_bounds::<Self>(offset);
7799 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7800 None => return Err(fidl::Error::NotNullable),
7801 Some(len) => len,
7802 };
7803 if len == 0 {
7805 return Ok(());
7806 };
7807 depth.increment()?;
7808 let envelope_size = 8;
7809 let bytes_len = len * envelope_size;
7810 let offset = decoder.out_of_line_offset(bytes_len)?;
7811 let mut _next_ordinal_to_read = 0;
7813 let mut next_offset = offset;
7814 let end_offset = offset + bytes_len;
7815 _next_ordinal_to_read += 1;
7816 if next_offset >= end_offset {
7817 return Ok(());
7818 }
7819
7820 while _next_ordinal_to_read < 1 {
7822 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7823 _next_ordinal_to_read += 1;
7824 next_offset += envelope_size;
7825 }
7826
7827 let next_out_of_line = decoder.next_out_of_line();
7828 let handles_before = decoder.remaining_handles();
7829 if let Some((inlined, num_bytes, num_handles)) =
7830 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7831 {
7832 let member_inline_size =
7833 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7834 if inlined != (member_inline_size <= 4) {
7835 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7836 }
7837 let inner_offset;
7838 let mut inner_depth = depth.clone();
7839 if inlined {
7840 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7841 inner_offset = next_offset;
7842 } else {
7843 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7844 inner_depth.increment()?;
7845 }
7846 let val_ref =
7847 self.valid_bits_per_sample.get_or_insert_with(|| fidl::new_empty!(u8, D));
7848 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7849 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7850 {
7851 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7852 }
7853 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7854 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7855 }
7856 }
7857
7858 next_offset += envelope_size;
7859 _next_ordinal_to_read += 1;
7860 if next_offset >= end_offset {
7861 return Ok(());
7862 }
7863
7864 while _next_ordinal_to_read < 2 {
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 <i64 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 = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
7891 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7892 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7893 {
7894 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7895 }
7896 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7897 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7898 }
7899 }
7900
7901 next_offset += envelope_size;
7902
7903 while next_offset < end_offset {
7905 _next_ordinal_to_read += 1;
7906 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7907 next_offset += envelope_size;
7908 }
7909
7910 Ok(())
7911 }
7912 }
7913
7914 impl RingBufferSetActiveChannelsRequest {
7915 #[inline(always)]
7916 fn max_ordinal_present(&self) -> u64 {
7917 if let Some(_) = self.channel_bitmask {
7918 return 1;
7919 }
7920 0
7921 }
7922 }
7923
7924 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsRequest {
7925 type Borrowed<'a> = &'a Self;
7926 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7927 value
7928 }
7929 }
7930
7931 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsRequest {
7932 type Owned = Self;
7933
7934 #[inline(always)]
7935 fn inline_align(_context: fidl::encoding::Context) -> usize {
7936 8
7937 }
7938
7939 #[inline(always)]
7940 fn inline_size(_context: fidl::encoding::Context) -> usize {
7941 16
7942 }
7943 }
7944
7945 unsafe impl<D: fidl::encoding::ResourceDialect>
7946 fidl::encoding::Encode<RingBufferSetActiveChannelsRequest, D>
7947 for &RingBufferSetActiveChannelsRequest
7948 {
7949 unsafe fn encode(
7950 self,
7951 encoder: &mut fidl::encoding::Encoder<'_, D>,
7952 offset: usize,
7953 mut depth: fidl::encoding::Depth,
7954 ) -> fidl::Result<()> {
7955 encoder.debug_check_bounds::<RingBufferSetActiveChannelsRequest>(offset);
7956 let max_ordinal: u64 = self.max_ordinal_present();
7958 encoder.write_num(max_ordinal, offset);
7959 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7960 if max_ordinal == 0 {
7962 return Ok(());
7963 }
7964 depth.increment()?;
7965 let envelope_size = 8;
7966 let bytes_len = max_ordinal as usize * envelope_size;
7967 #[allow(unused_variables)]
7968 let offset = encoder.out_of_line_offset(bytes_len);
7969 let mut _prev_end_offset: usize = 0;
7970 if 1 > max_ordinal {
7971 return Ok(());
7972 }
7973
7974 let cur_offset: usize = (1 - 1) * envelope_size;
7977
7978 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7980
7981 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7986 self.channel_bitmask.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7987 encoder,
7988 offset + cur_offset,
7989 depth,
7990 )?;
7991
7992 _prev_end_offset = cur_offset + envelope_size;
7993
7994 Ok(())
7995 }
7996 }
7997
7998 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7999 for RingBufferSetActiveChannelsRequest
8000 {
8001 #[inline(always)]
8002 fn new_empty() -> Self {
8003 Self::default()
8004 }
8005
8006 unsafe fn decode(
8007 &mut self,
8008 decoder: &mut fidl::encoding::Decoder<'_, D>,
8009 offset: usize,
8010 mut depth: fidl::encoding::Depth,
8011 ) -> fidl::Result<()> {
8012 decoder.debug_check_bounds::<Self>(offset);
8013 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8014 None => return Err(fidl::Error::NotNullable),
8015 Some(len) => len,
8016 };
8017 if len == 0 {
8019 return Ok(());
8020 };
8021 depth.increment()?;
8022 let envelope_size = 8;
8023 let bytes_len = len * envelope_size;
8024 let offset = decoder.out_of_line_offset(bytes_len)?;
8025 let mut _next_ordinal_to_read = 0;
8027 let mut next_offset = offset;
8028 let end_offset = offset + bytes_len;
8029 _next_ordinal_to_read += 1;
8030 if next_offset >= end_offset {
8031 return Ok(());
8032 }
8033
8034 while _next_ordinal_to_read < 1 {
8036 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8037 _next_ordinal_to_read += 1;
8038 next_offset += envelope_size;
8039 }
8040
8041 let next_out_of_line = decoder.next_out_of_line();
8042 let handles_before = decoder.remaining_handles();
8043 if let Some((inlined, num_bytes, num_handles)) =
8044 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8045 {
8046 let member_inline_size =
8047 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8048 if inlined != (member_inline_size <= 4) {
8049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8050 }
8051 let inner_offset;
8052 let mut inner_depth = depth.clone();
8053 if inlined {
8054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8055 inner_offset = next_offset;
8056 } else {
8057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8058 inner_depth.increment()?;
8059 }
8060 let val_ref = self.channel_bitmask.get_or_insert_with(|| fidl::new_empty!(u64, D));
8061 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8062 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8063 {
8064 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8065 }
8066 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8067 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8068 }
8069 }
8070
8071 next_offset += envelope_size;
8072
8073 while next_offset < end_offset {
8075 _next_ordinal_to_read += 1;
8076 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8077 next_offset += envelope_size;
8078 }
8079
8080 Ok(())
8081 }
8082 }
8083
8084 impl RingBufferStartRequest {
8085 #[inline(always)]
8086 fn max_ordinal_present(&self) -> u64 {
8087 0
8088 }
8089 }
8090
8091 impl fidl::encoding::ValueTypeMarker for RingBufferStartRequest {
8092 type Borrowed<'a> = &'a Self;
8093 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8094 value
8095 }
8096 }
8097
8098 unsafe impl fidl::encoding::TypeMarker for RingBufferStartRequest {
8099 type Owned = Self;
8100
8101 #[inline(always)]
8102 fn inline_align(_context: fidl::encoding::Context) -> usize {
8103 8
8104 }
8105
8106 #[inline(always)]
8107 fn inline_size(_context: fidl::encoding::Context) -> usize {
8108 16
8109 }
8110 }
8111
8112 unsafe impl<D: fidl::encoding::ResourceDialect>
8113 fidl::encoding::Encode<RingBufferStartRequest, D> for &RingBufferStartRequest
8114 {
8115 unsafe fn encode(
8116 self,
8117 encoder: &mut fidl::encoding::Encoder<'_, D>,
8118 offset: usize,
8119 mut depth: fidl::encoding::Depth,
8120 ) -> fidl::Result<()> {
8121 encoder.debug_check_bounds::<RingBufferStartRequest>(offset);
8122 let max_ordinal: u64 = self.max_ordinal_present();
8124 encoder.write_num(max_ordinal, offset);
8125 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8126 if max_ordinal == 0 {
8128 return Ok(());
8129 }
8130 depth.increment()?;
8131 let envelope_size = 8;
8132 let bytes_len = max_ordinal as usize * envelope_size;
8133 #[allow(unused_variables)]
8134 let offset = encoder.out_of_line_offset(bytes_len);
8135 let mut _prev_end_offset: usize = 0;
8136
8137 Ok(())
8138 }
8139 }
8140
8141 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8142 for RingBufferStartRequest
8143 {
8144 #[inline(always)]
8145 fn new_empty() -> Self {
8146 Self::default()
8147 }
8148
8149 unsafe fn decode(
8150 &mut self,
8151 decoder: &mut fidl::encoding::Decoder<'_, D>,
8152 offset: usize,
8153 mut depth: fidl::encoding::Depth,
8154 ) -> fidl::Result<()> {
8155 decoder.debug_check_bounds::<Self>(offset);
8156 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8157 None => return Err(fidl::Error::NotNullable),
8158 Some(len) => len,
8159 };
8160 if len == 0 {
8162 return Ok(());
8163 };
8164 depth.increment()?;
8165 let envelope_size = 8;
8166 let bytes_len = len * envelope_size;
8167 let offset = decoder.out_of_line_offset(bytes_len)?;
8168 let mut _next_ordinal_to_read = 0;
8170 let mut next_offset = offset;
8171 let end_offset = offset + bytes_len;
8172
8173 while next_offset < end_offset {
8175 _next_ordinal_to_read += 1;
8176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8177 next_offset += envelope_size;
8178 }
8179
8180 Ok(())
8181 }
8182 }
8183
8184 impl RingBufferStopRequest {
8185 #[inline(always)]
8186 fn max_ordinal_present(&self) -> u64 {
8187 0
8188 }
8189 }
8190
8191 impl fidl::encoding::ValueTypeMarker for RingBufferStopRequest {
8192 type Borrowed<'a> = &'a Self;
8193 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8194 value
8195 }
8196 }
8197
8198 unsafe impl fidl::encoding::TypeMarker for RingBufferStopRequest {
8199 type Owned = Self;
8200
8201 #[inline(always)]
8202 fn inline_align(_context: fidl::encoding::Context) -> usize {
8203 8
8204 }
8205
8206 #[inline(always)]
8207 fn inline_size(_context: fidl::encoding::Context) -> usize {
8208 16
8209 }
8210 }
8211
8212 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferStopRequest, D>
8213 for &RingBufferStopRequest
8214 {
8215 unsafe fn encode(
8216 self,
8217 encoder: &mut fidl::encoding::Encoder<'_, D>,
8218 offset: usize,
8219 mut depth: fidl::encoding::Depth,
8220 ) -> fidl::Result<()> {
8221 encoder.debug_check_bounds::<RingBufferStopRequest>(offset);
8222 let max_ordinal: u64 = self.max_ordinal_present();
8224 encoder.write_num(max_ordinal, offset);
8225 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8226 if max_ordinal == 0 {
8228 return Ok(());
8229 }
8230 depth.increment()?;
8231 let envelope_size = 8;
8232 let bytes_len = max_ordinal as usize * envelope_size;
8233 #[allow(unused_variables)]
8234 let offset = encoder.out_of_line_offset(bytes_len);
8235 let mut _prev_end_offset: usize = 0;
8236
8237 Ok(())
8238 }
8239 }
8240
8241 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopRequest {
8242 #[inline(always)]
8243 fn new_empty() -> Self {
8244 Self::default()
8245 }
8246
8247 unsafe fn decode(
8248 &mut self,
8249 decoder: &mut fidl::encoding::Decoder<'_, D>,
8250 offset: usize,
8251 mut depth: fidl::encoding::Depth,
8252 ) -> fidl::Result<()> {
8253 decoder.debug_check_bounds::<Self>(offset);
8254 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8255 None => return Err(fidl::Error::NotNullable),
8256 Some(len) => len,
8257 };
8258 if len == 0 {
8260 return Ok(());
8261 };
8262 depth.increment()?;
8263 let envelope_size = 8;
8264 let bytes_len = len * envelope_size;
8265 let offset = decoder.out_of_line_offset(bytes_len)?;
8266 let mut _next_ordinal_to_read = 0;
8268 let mut next_offset = offset;
8269 let end_offset = offset + bytes_len;
8270
8271 while next_offset < end_offset {
8273 _next_ordinal_to_read += 1;
8274 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8275 next_offset += envelope_size;
8276 }
8277
8278 Ok(())
8279 }
8280 }
8281
8282 impl RingBufferSetActiveChannelsResponse {
8283 #[inline(always)]
8284 fn max_ordinal_present(&self) -> u64 {
8285 if let Some(_) = self.set_time {
8286 return 1;
8287 }
8288 0
8289 }
8290 }
8291
8292 impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsResponse {
8293 type Borrowed<'a> = &'a Self;
8294 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8295 value
8296 }
8297 }
8298
8299 unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsResponse {
8300 type Owned = Self;
8301
8302 #[inline(always)]
8303 fn inline_align(_context: fidl::encoding::Context) -> usize {
8304 8
8305 }
8306
8307 #[inline(always)]
8308 fn inline_size(_context: fidl::encoding::Context) -> usize {
8309 16
8310 }
8311 }
8312
8313 unsafe impl<D: fidl::encoding::ResourceDialect>
8314 fidl::encoding::Encode<RingBufferSetActiveChannelsResponse, D>
8315 for &RingBufferSetActiveChannelsResponse
8316 {
8317 unsafe fn encode(
8318 self,
8319 encoder: &mut fidl::encoding::Encoder<'_, D>,
8320 offset: usize,
8321 mut depth: fidl::encoding::Depth,
8322 ) -> fidl::Result<()> {
8323 encoder.debug_check_bounds::<RingBufferSetActiveChannelsResponse>(offset);
8324 let max_ordinal: u64 = self.max_ordinal_present();
8326 encoder.write_num(max_ordinal, offset);
8327 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8328 if max_ordinal == 0 {
8330 return Ok(());
8331 }
8332 depth.increment()?;
8333 let envelope_size = 8;
8334 let bytes_len = max_ordinal as usize * envelope_size;
8335 #[allow(unused_variables)]
8336 let offset = encoder.out_of_line_offset(bytes_len);
8337 let mut _prev_end_offset: usize = 0;
8338 if 1 > max_ordinal {
8339 return Ok(());
8340 }
8341
8342 let cur_offset: usize = (1 - 1) * envelope_size;
8345
8346 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8348
8349 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8354 self.set_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8355 encoder,
8356 offset + cur_offset,
8357 depth,
8358 )?;
8359
8360 _prev_end_offset = cur_offset + envelope_size;
8361
8362 Ok(())
8363 }
8364 }
8365
8366 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8367 for RingBufferSetActiveChannelsResponse
8368 {
8369 #[inline(always)]
8370 fn new_empty() -> Self {
8371 Self::default()
8372 }
8373
8374 unsafe fn decode(
8375 &mut self,
8376 decoder: &mut fidl::encoding::Decoder<'_, D>,
8377 offset: usize,
8378 mut depth: fidl::encoding::Depth,
8379 ) -> fidl::Result<()> {
8380 decoder.debug_check_bounds::<Self>(offset);
8381 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8382 None => return Err(fidl::Error::NotNullable),
8383 Some(len) => len,
8384 };
8385 if len == 0 {
8387 return Ok(());
8388 };
8389 depth.increment()?;
8390 let envelope_size = 8;
8391 let bytes_len = len * envelope_size;
8392 let offset = decoder.out_of_line_offset(bytes_len)?;
8393 let mut _next_ordinal_to_read = 0;
8395 let mut next_offset = offset;
8396 let end_offset = offset + bytes_len;
8397 _next_ordinal_to_read += 1;
8398 if next_offset >= end_offset {
8399 return Ok(());
8400 }
8401
8402 while _next_ordinal_to_read < 1 {
8404 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8405 _next_ordinal_to_read += 1;
8406 next_offset += envelope_size;
8407 }
8408
8409 let next_out_of_line = decoder.next_out_of_line();
8410 let handles_before = decoder.remaining_handles();
8411 if let Some((inlined, num_bytes, num_handles)) =
8412 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8413 {
8414 let member_inline_size =
8415 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8416 if inlined != (member_inline_size <= 4) {
8417 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8418 }
8419 let inner_offset;
8420 let mut inner_depth = depth.clone();
8421 if inlined {
8422 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8423 inner_offset = next_offset;
8424 } else {
8425 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8426 inner_depth.increment()?;
8427 }
8428 let val_ref = self.set_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8429 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8430 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8431 {
8432 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8433 }
8434 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8435 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8436 }
8437 }
8438
8439 next_offset += envelope_size;
8440
8441 while next_offset < end_offset {
8443 _next_ordinal_to_read += 1;
8444 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8445 next_offset += envelope_size;
8446 }
8447
8448 Ok(())
8449 }
8450 }
8451
8452 impl RingBufferStartResponse {
8453 #[inline(always)]
8454 fn max_ordinal_present(&self) -> u64 {
8455 if let Some(_) = self.start_time {
8456 return 1;
8457 }
8458 0
8459 }
8460 }
8461
8462 impl fidl::encoding::ValueTypeMarker for RingBufferStartResponse {
8463 type Borrowed<'a> = &'a Self;
8464 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8465 value
8466 }
8467 }
8468
8469 unsafe impl fidl::encoding::TypeMarker for RingBufferStartResponse {
8470 type Owned = Self;
8471
8472 #[inline(always)]
8473 fn inline_align(_context: fidl::encoding::Context) -> usize {
8474 8
8475 }
8476
8477 #[inline(always)]
8478 fn inline_size(_context: fidl::encoding::Context) -> usize {
8479 16
8480 }
8481 }
8482
8483 unsafe impl<D: fidl::encoding::ResourceDialect>
8484 fidl::encoding::Encode<RingBufferStartResponse, D> for &RingBufferStartResponse
8485 {
8486 unsafe fn encode(
8487 self,
8488 encoder: &mut fidl::encoding::Encoder<'_, D>,
8489 offset: usize,
8490 mut depth: fidl::encoding::Depth,
8491 ) -> fidl::Result<()> {
8492 encoder.debug_check_bounds::<RingBufferStartResponse>(offset);
8493 let max_ordinal: u64 = self.max_ordinal_present();
8495 encoder.write_num(max_ordinal, offset);
8496 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8497 if max_ordinal == 0 {
8499 return Ok(());
8500 }
8501 depth.increment()?;
8502 let envelope_size = 8;
8503 let bytes_len = max_ordinal as usize * envelope_size;
8504 #[allow(unused_variables)]
8505 let offset = encoder.out_of_line_offset(bytes_len);
8506 let mut _prev_end_offset: usize = 0;
8507 if 1 > max_ordinal {
8508 return Ok(());
8509 }
8510
8511 let cur_offset: usize = (1 - 1) * envelope_size;
8514
8515 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8517
8518 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8523 self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8524 encoder,
8525 offset + cur_offset,
8526 depth,
8527 )?;
8528
8529 _prev_end_offset = cur_offset + envelope_size;
8530
8531 Ok(())
8532 }
8533 }
8534
8535 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8536 for RingBufferStartResponse
8537 {
8538 #[inline(always)]
8539 fn new_empty() -> Self {
8540 Self::default()
8541 }
8542
8543 unsafe fn decode(
8544 &mut self,
8545 decoder: &mut fidl::encoding::Decoder<'_, D>,
8546 offset: usize,
8547 mut depth: fidl::encoding::Depth,
8548 ) -> fidl::Result<()> {
8549 decoder.debug_check_bounds::<Self>(offset);
8550 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8551 None => return Err(fidl::Error::NotNullable),
8552 Some(len) => len,
8553 };
8554 if len == 0 {
8556 return Ok(());
8557 };
8558 depth.increment()?;
8559 let envelope_size = 8;
8560 let bytes_len = len * envelope_size;
8561 let offset = decoder.out_of_line_offset(bytes_len)?;
8562 let mut _next_ordinal_to_read = 0;
8564 let mut next_offset = offset;
8565 let end_offset = offset + bytes_len;
8566 _next_ordinal_to_read += 1;
8567 if next_offset >= end_offset {
8568 return Ok(());
8569 }
8570
8571 while _next_ordinal_to_read < 1 {
8573 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8574 _next_ordinal_to_read += 1;
8575 next_offset += envelope_size;
8576 }
8577
8578 let next_out_of_line = decoder.next_out_of_line();
8579 let handles_before = decoder.remaining_handles();
8580 if let Some((inlined, num_bytes, num_handles)) =
8581 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8582 {
8583 let member_inline_size =
8584 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8585 if inlined != (member_inline_size <= 4) {
8586 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8587 }
8588 let inner_offset;
8589 let mut inner_depth = depth.clone();
8590 if inlined {
8591 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8592 inner_offset = next_offset;
8593 } else {
8594 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8595 inner_depth.increment()?;
8596 }
8597 let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8598 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8599 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8600 {
8601 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8602 }
8603 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8604 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8605 }
8606 }
8607
8608 next_offset += envelope_size;
8609
8610 while next_offset < end_offset {
8612 _next_ordinal_to_read += 1;
8613 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8614 next_offset += envelope_size;
8615 }
8616
8617 Ok(())
8618 }
8619 }
8620
8621 impl RingBufferStopResponse {
8622 #[inline(always)]
8623 fn max_ordinal_present(&self) -> u64 {
8624 0
8625 }
8626 }
8627
8628 impl fidl::encoding::ValueTypeMarker for RingBufferStopResponse {
8629 type Borrowed<'a> = &'a Self;
8630 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8631 value
8632 }
8633 }
8634
8635 unsafe impl fidl::encoding::TypeMarker for RingBufferStopResponse {
8636 type Owned = Self;
8637
8638 #[inline(always)]
8639 fn inline_align(_context: fidl::encoding::Context) -> usize {
8640 8
8641 }
8642
8643 #[inline(always)]
8644 fn inline_size(_context: fidl::encoding::Context) -> usize {
8645 16
8646 }
8647 }
8648
8649 unsafe impl<D: fidl::encoding::ResourceDialect>
8650 fidl::encoding::Encode<RingBufferStopResponse, D> for &RingBufferStopResponse
8651 {
8652 unsafe fn encode(
8653 self,
8654 encoder: &mut fidl::encoding::Encoder<'_, D>,
8655 offset: usize,
8656 mut depth: fidl::encoding::Depth,
8657 ) -> fidl::Result<()> {
8658 encoder.debug_check_bounds::<RingBufferStopResponse>(offset);
8659 let max_ordinal: u64 = self.max_ordinal_present();
8661 encoder.write_num(max_ordinal, offset);
8662 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8663 if max_ordinal == 0 {
8665 return Ok(());
8666 }
8667 depth.increment()?;
8668 let envelope_size = 8;
8669 let bytes_len = max_ordinal as usize * envelope_size;
8670 #[allow(unused_variables)]
8671 let offset = encoder.out_of_line_offset(bytes_len);
8672 let mut _prev_end_offset: usize = 0;
8673
8674 Ok(())
8675 }
8676 }
8677
8678 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8679 for RingBufferStopResponse
8680 {
8681 #[inline(always)]
8682 fn new_empty() -> Self {
8683 Self::default()
8684 }
8685
8686 unsafe fn decode(
8687 &mut self,
8688 decoder: &mut fidl::encoding::Decoder<'_, D>,
8689 offset: usize,
8690 mut depth: fidl::encoding::Depth,
8691 ) -> fidl::Result<()> {
8692 decoder.debug_check_bounds::<Self>(offset);
8693 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8694 None => return Err(fidl::Error::NotNullable),
8695 Some(len) => len,
8696 };
8697 if len == 0 {
8699 return Ok(());
8700 };
8701 depth.increment()?;
8702 let envelope_size = 8;
8703 let bytes_len = len * envelope_size;
8704 let offset = decoder.out_of_line_offset(bytes_len)?;
8705 let mut _next_ordinal_to_read = 0;
8707 let mut next_offset = offset;
8708 let end_offset = offset + bytes_len;
8709
8710 while next_offset < end_offset {
8712 _next_ordinal_to_read += 1;
8713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8714 next_offset += envelope_size;
8715 }
8716
8717 Ok(())
8718 }
8719 }
8720
8721 impl RingBufferWatchDelayInfoResponse {
8722 #[inline(always)]
8723 fn max_ordinal_present(&self) -> u64 {
8724 if let Some(_) = self.delay_info {
8725 return 1;
8726 }
8727 0
8728 }
8729 }
8730
8731 impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoResponse {
8732 type Borrowed<'a> = &'a Self;
8733 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8734 value
8735 }
8736 }
8737
8738 unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoResponse {
8739 type Owned = Self;
8740
8741 #[inline(always)]
8742 fn inline_align(_context: fidl::encoding::Context) -> usize {
8743 8
8744 }
8745
8746 #[inline(always)]
8747 fn inline_size(_context: fidl::encoding::Context) -> usize {
8748 16
8749 }
8750 }
8751
8752 unsafe impl<D: fidl::encoding::ResourceDialect>
8753 fidl::encoding::Encode<RingBufferWatchDelayInfoResponse, D>
8754 for &RingBufferWatchDelayInfoResponse
8755 {
8756 unsafe fn encode(
8757 self,
8758 encoder: &mut fidl::encoding::Encoder<'_, D>,
8759 offset: usize,
8760 mut depth: fidl::encoding::Depth,
8761 ) -> fidl::Result<()> {
8762 encoder.debug_check_bounds::<RingBufferWatchDelayInfoResponse>(offset);
8763 let max_ordinal: u64 = self.max_ordinal_present();
8765 encoder.write_num(max_ordinal, offset);
8766 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8767 if max_ordinal == 0 {
8769 return Ok(());
8770 }
8771 depth.increment()?;
8772 let envelope_size = 8;
8773 let bytes_len = max_ordinal as usize * envelope_size;
8774 #[allow(unused_variables)]
8775 let offset = encoder.out_of_line_offset(bytes_len);
8776 let mut _prev_end_offset: usize = 0;
8777 if 1 > max_ordinal {
8778 return Ok(());
8779 }
8780
8781 let cur_offset: usize = (1 - 1) * envelope_size;
8784
8785 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8787
8788 fidl::encoding::encode_in_envelope_optional::<DelayInfo, D>(
8793 self.delay_info
8794 .as_ref()
8795 .map(<DelayInfo as fidl::encoding::ValueTypeMarker>::borrow),
8796 encoder,
8797 offset + cur_offset,
8798 depth,
8799 )?;
8800
8801 _prev_end_offset = cur_offset + envelope_size;
8802
8803 Ok(())
8804 }
8805 }
8806
8807 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8808 for RingBufferWatchDelayInfoResponse
8809 {
8810 #[inline(always)]
8811 fn new_empty() -> Self {
8812 Self::default()
8813 }
8814
8815 unsafe fn decode(
8816 &mut self,
8817 decoder: &mut fidl::encoding::Decoder<'_, D>,
8818 offset: usize,
8819 mut depth: fidl::encoding::Depth,
8820 ) -> fidl::Result<()> {
8821 decoder.debug_check_bounds::<Self>(offset);
8822 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8823 None => return Err(fidl::Error::NotNullable),
8824 Some(len) => len,
8825 };
8826 if len == 0 {
8828 return Ok(());
8829 };
8830 depth.increment()?;
8831 let envelope_size = 8;
8832 let bytes_len = len * envelope_size;
8833 let offset = decoder.out_of_line_offset(bytes_len)?;
8834 let mut _next_ordinal_to_read = 0;
8836 let mut next_offset = offset;
8837 let end_offset = offset + bytes_len;
8838 _next_ordinal_to_read += 1;
8839 if next_offset >= end_offset {
8840 return Ok(());
8841 }
8842
8843 while _next_ordinal_to_read < 1 {
8845 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8846 _next_ordinal_to_read += 1;
8847 next_offset += envelope_size;
8848 }
8849
8850 let next_out_of_line = decoder.next_out_of_line();
8851 let handles_before = decoder.remaining_handles();
8852 if let Some((inlined, num_bytes, num_handles)) =
8853 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8854 {
8855 let member_inline_size =
8856 <DelayInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8857 if inlined != (member_inline_size <= 4) {
8858 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8859 }
8860 let inner_offset;
8861 let mut inner_depth = depth.clone();
8862 if inlined {
8863 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8864 inner_offset = next_offset;
8865 } else {
8866 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8867 inner_depth.increment()?;
8868 }
8869 let val_ref = self.delay_info.get_or_insert_with(|| fidl::new_empty!(DelayInfo, D));
8870 fidl::decode!(DelayInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
8871 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8872 {
8873 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8874 }
8875 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8876 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8877 }
8878 }
8879
8880 next_offset += envelope_size;
8881
8882 while next_offset < end_offset {
8884 _next_ordinal_to_read += 1;
8885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8886 next_offset += envelope_size;
8887 }
8888
8889 Ok(())
8890 }
8891 }
8892}