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 ChannelMode = fidl_fuchsia_bluetooth__common::ChannelMode;
12
13pub type ChannelParameters = fidl_fuchsia_bluetooth__common::ChannelParameters;
14
15pub type ProtocolDescriptorList = Vec<ProtocolDescriptor>;
18
19pub type RfcommChannel = u8;
23
24pub const ATTR_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST: u16 = 13;
25
26pub const ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST: u16 = 9;
27
28pub const ATTR_BROWSE_GROUP_LIST: u16 = 5;
29
30pub const ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST: u16 = 6;
31
32pub const ATTR_PROTOCOL_DESCRIPTOR_LIST: u16 = 4;
33
34pub const ATTR_SERVICE_AVAILABILITY: u16 = 8;
35
36pub const ATTR_SERVICE_CLASS_ID_LIST: u16 = 1;
37
38pub const ATTR_SERVICE_ID: u16 = 3;
39
40pub const ATTR_SERVICE_INFO_TIME_TO_LIVE: u16 = 7;
41
42pub const ATTR_SERVICE_RECORD_HANDLE: u16 = 0;
45
46pub const ATTR_SERVICE_RECORD_STATE: u16 = 2;
47
48pub const MAX_ADDITIONAL_ATTRIBUTES: u16 = 65023;
52
53pub const MAX_ATTRIBUTES: u16 = 512;
55
56pub const MAX_INFORMATION_COUNT: u8 = 85;
58
59pub const MAX_SEQUENCE_LENGTH: u8 = 255;
63
64pub const MAX_SERVICES_PER_ADVERTISEMENT: u8 = 32;
66
67pub const MAX_STRING_LENGTH: u16 = 1024;
70
71pub const PSM_3_DSP: u16 = 33;
72
73pub const PSM_ATT: u16 = 31;
74
75pub const PSM_AVCTP: u16 = 23;
76
77pub const PSM_AVCTP_BROWSE: u16 = 27;
78
79pub const PSM_AVDTP: u16 = 25;
80
81pub const PSM_BNEP: u16 = 15;
82
83pub const PSM_DYNAMIC: u16 = 65535;
89
90pub const PSM_HID_CONTROL: u16 = 17;
91
92pub const PSM_HID_INTERRUPT: u16 = 19;
93
94pub const PSM_LE_IPSP: u16 = 35;
95
96pub const PSM_OTS: u16 = 37;
97
98pub const PSM_RFCOMM: u16 = 3;
99
100pub const PSM_SDP: u16 = 1;
104
105pub const PSM_TCSBIN: u16 = 5;
106
107pub const PSM_TCSBIN_CORDLESS: u16 = 7;
108
109#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112#[repr(u32)]
113pub enum A2dpDirectionPriority {
114 Normal = 1,
115 Source = 2,
116 Sink = 3,
117}
118
119impl A2dpDirectionPriority {
120 #[inline]
121 pub fn from_primitive(prim: u32) -> Option<Self> {
122 match prim {
123 1 => Some(Self::Normal),
124 2 => Some(Self::Source),
125 3 => Some(Self::Sink),
126 _ => None,
127 }
128 }
129
130 #[inline]
131 pub const fn into_primitive(self) -> u32 {
132 self as u32
133 }
134}
135
136#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
137pub enum AudioBitsPerSample {
138 Bps16,
139 Bps24,
140 Bps32,
141 #[doc(hidden)]
142 __SourceBreaking {
143 unknown_ordinal: u8,
144 },
145}
146
147#[macro_export]
149macro_rules! AudioBitsPerSampleUnknown {
150 () => {
151 _
152 };
153}
154
155impl AudioBitsPerSample {
156 #[inline]
157 pub fn from_primitive(prim: u8) -> Option<Self> {
158 match prim {
159 1 => Some(Self::Bps16),
160 2 => Some(Self::Bps24),
161 3 => Some(Self::Bps32),
162 _ => None,
163 }
164 }
165
166 #[inline]
167 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
168 match prim {
169 1 => Self::Bps16,
170 2 => Self::Bps24,
171 3 => Self::Bps32,
172 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
173 }
174 }
175
176 #[inline]
177 pub fn unknown() -> Self {
178 Self::__SourceBreaking { unknown_ordinal: 0xff }
179 }
180
181 #[inline]
182 pub const fn into_primitive(self) -> u8 {
183 match self {
184 Self::Bps16 => 1,
185 Self::Bps24 => 2,
186 Self::Bps32 => 3,
187 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
188 }
189 }
190
191 #[inline]
192 pub fn is_unknown(&self) -> bool {
193 match self {
194 Self::__SourceBreaking { unknown_ordinal: _ } => true,
195 _ => false,
196 }
197 }
198}
199
200#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
201pub enum AudioChannelMode {
202 Mono,
203 Stereo,
204 #[doc(hidden)]
205 __SourceBreaking {
206 unknown_ordinal: u8,
207 },
208}
209
210#[macro_export]
212macro_rules! AudioChannelModeUnknown {
213 () => {
214 _
215 };
216}
217
218impl AudioChannelMode {
219 #[inline]
220 pub fn from_primitive(prim: u8) -> Option<Self> {
221 match prim {
222 0 => Some(Self::Mono),
223 1 => Some(Self::Stereo),
224 _ => None,
225 }
226 }
227
228 #[inline]
229 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
230 match prim {
231 0 => Self::Mono,
232 1 => Self::Stereo,
233 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
234 }
235 }
236
237 #[inline]
238 pub fn unknown() -> Self {
239 Self::__SourceBreaking { unknown_ordinal: 0xff }
240 }
241
242 #[inline]
243 pub const fn into_primitive(self) -> u8 {
244 match self {
245 Self::Mono => 0,
246 Self::Stereo => 1,
247 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
248 }
249 }
250
251 #[inline]
252 pub fn is_unknown(&self) -> bool {
253 match self {
254 Self::__SourceBreaking { unknown_ordinal: _ } => true,
255 _ => false,
256 }
257 }
258}
259
260#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
261pub enum AudioSamplingFrequency {
262 Hz44100,
263 Hz48000,
264 Hz88200,
265 Hz96000,
266 #[doc(hidden)]
267 __SourceBreaking {
268 unknown_ordinal: u8,
269 },
270}
271
272#[macro_export]
274macro_rules! AudioSamplingFrequencyUnknown {
275 () => {
276 _
277 };
278}
279
280impl AudioSamplingFrequency {
281 #[inline]
282 pub fn from_primitive(prim: u8) -> Option<Self> {
283 match prim {
284 1 => Some(Self::Hz44100),
285 2 => Some(Self::Hz48000),
286 3 => Some(Self::Hz88200),
287 4 => Some(Self::Hz96000),
288 _ => None,
289 }
290 }
291
292 #[inline]
293 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
294 match prim {
295 1 => Self::Hz44100,
296 2 => Self::Hz48000,
297 3 => Self::Hz88200,
298 4 => Self::Hz96000,
299 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
300 }
301 }
302
303 #[inline]
304 pub fn unknown() -> Self {
305 Self::__SourceBreaking { unknown_ordinal: 0xff }
306 }
307
308 #[inline]
309 pub const fn into_primitive(self) -> u8 {
310 match self {
311 Self::Hz44100 => 1,
312 Self::Hz48000 => 2,
313 Self::Hz88200 => 3,
314 Self::Hz96000 => 4,
315 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
316 }
317 }
318
319 #[inline]
320 pub fn is_unknown(&self) -> bool {
321 match self {
322 Self::__SourceBreaking { unknown_ordinal: _ } => true,
323 _ => false,
324 }
325 }
326}
327
328#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
331#[repr(u8)]
332pub enum DataPath {
333 Host = 1,
335 Offload = 2,
338 Test = 3,
340}
341
342impl DataPath {
343 #[inline]
344 pub fn from_primitive(prim: u8) -> Option<Self> {
345 match prim {
346 1 => Some(Self::Host),
347 2 => Some(Self::Offload),
348 3 => Some(Self::Test),
349 _ => None,
350 }
351 }
352
353 #[inline]
354 pub const fn into_primitive(self) -> u8 {
355 self as u8
356 }
357}
358
359#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
361pub enum HfpParameterSet {
362 T1,
363 T2,
364 S1,
365 S2,
366 S3,
367 S4,
368 D0,
369 D1,
370 #[doc(hidden)]
371 __SourceBreaking {
372 unknown_ordinal: u8,
373 },
374}
375
376#[macro_export]
378macro_rules! HfpParameterSetUnknown {
379 () => {
380 _
381 };
382}
383
384impl HfpParameterSet {
385 #[inline]
386 pub fn from_primitive(prim: u8) -> Option<Self> {
387 match prim {
388 1 => Some(Self::T1),
389 2 => Some(Self::T2),
390 3 => Some(Self::S1),
391 4 => Some(Self::S2),
392 5 => Some(Self::S3),
393 6 => Some(Self::S4),
394 7 => Some(Self::D0),
395 8 => Some(Self::D1),
396 _ => None,
397 }
398 }
399
400 #[inline]
401 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
402 match prim {
403 1 => Self::T1,
404 2 => Self::T2,
405 3 => Self::S1,
406 4 => Self::S2,
407 5 => Self::S3,
408 6 => Self::S4,
409 7 => Self::D0,
410 8 => Self::D1,
411 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
412 }
413 }
414
415 #[inline]
416 pub fn unknown() -> Self {
417 Self::__SourceBreaking { unknown_ordinal: 0xff }
418 }
419
420 #[inline]
421 pub const fn into_primitive(self) -> u8 {
422 match self {
423 Self::T1 => 1,
424 Self::T2 => 2,
425 Self::S1 => 3,
426 Self::S2 => 4,
427 Self::S3 => 5,
428 Self::S4 => 6,
429 Self::D0 => 7,
430 Self::D1 => 8,
431 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
432 }
433 }
434
435 #[inline]
436 pub fn is_unknown(&self) -> bool {
437 match self {
438 Self::__SourceBreaking { unknown_ordinal: _ } => true,
439 _ => false,
440 }
441 }
442}
443
444#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
449pub enum ProtocolIdentifier {
450 Sdp,
451 Rfcomm,
452 Att,
453 Obex,
454 Bnep,
455 Hidp,
456 HardcopyControlChannel,
457 HardcopyDataChannel,
458 HardcopyNotification,
459 Avctp,
460 Avdtp,
461 McapControlChannel,
462 McapDataChannel,
463 L2Cap,
464 #[doc(hidden)]
465 __SourceBreaking {
466 unknown_ordinal: u16,
467 },
468}
469
470#[macro_export]
472macro_rules! ProtocolIdentifierUnknown {
473 () => {
474 _
475 };
476}
477
478impl ProtocolIdentifier {
479 #[inline]
480 pub fn from_primitive(prim: u16) -> Option<Self> {
481 match prim {
482 1 => Some(Self::Sdp),
483 3 => Some(Self::Rfcomm),
484 7 => Some(Self::Att),
485 8 => Some(Self::Obex),
486 15 => Some(Self::Bnep),
487 17 => Some(Self::Hidp),
488 18 => Some(Self::HardcopyControlChannel),
489 20 => Some(Self::HardcopyDataChannel),
490 22 => Some(Self::HardcopyNotification),
491 23 => Some(Self::Avctp),
492 25 => Some(Self::Avdtp),
493 30 => Some(Self::McapControlChannel),
494 31 => Some(Self::McapDataChannel),
495 256 => Some(Self::L2Cap),
496 _ => None,
497 }
498 }
499
500 #[inline]
501 pub fn from_primitive_allow_unknown(prim: u16) -> Self {
502 match prim {
503 1 => Self::Sdp,
504 3 => Self::Rfcomm,
505 7 => Self::Att,
506 8 => Self::Obex,
507 15 => Self::Bnep,
508 17 => Self::Hidp,
509 18 => Self::HardcopyControlChannel,
510 20 => Self::HardcopyDataChannel,
511 22 => Self::HardcopyNotification,
512 23 => Self::Avctp,
513 25 => Self::Avdtp,
514 30 => Self::McapControlChannel,
515 31 => Self::McapDataChannel,
516 256 => Self::L2Cap,
517 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
518 }
519 }
520
521 #[inline]
522 pub fn unknown() -> Self {
523 Self::__SourceBreaking { unknown_ordinal: 0xffff }
524 }
525
526 #[inline]
527 pub const fn into_primitive(self) -> u16 {
528 match self {
529 Self::Sdp => 1,
530 Self::Rfcomm => 3,
531 Self::Att => 7,
532 Self::Obex => 8,
533 Self::Bnep => 15,
534 Self::Hidp => 17,
535 Self::HardcopyControlChannel => 18,
536 Self::HardcopyDataChannel => 20,
537 Self::HardcopyNotification => 22,
538 Self::Avctp => 23,
539 Self::Avdtp => 25,
540 Self::McapControlChannel => 30,
541 Self::McapDataChannel => 31,
542 Self::L2Cap => 256,
543 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
544 }
545 }
546
547 #[inline]
548 pub fn is_unknown(&self) -> bool {
549 match self {
550 Self::__SourceBreaking { unknown_ordinal: _ } => true,
551 _ => false,
552 }
553 }
554}
555
556#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
558#[repr(u8)]
559pub enum RxPacketStatus {
560 CorrectlyReceivedData = 0,
562 PossiblyInvalidData = 1,
564 NoDataReceived = 2,
566 DataPartiallyLost = 3,
568}
569
570impl RxPacketStatus {
571 #[inline]
572 pub fn from_primitive(prim: u8) -> Option<Self> {
573 match prim {
574 0 => Some(Self::CorrectlyReceivedData),
575 1 => Some(Self::PossiblyInvalidData),
576 2 => Some(Self::NoDataReceived),
577 3 => Some(Self::DataPartiallyLost),
578 _ => None,
579 }
580 }
581
582 #[inline]
583 pub const fn into_primitive(self) -> u8 {
584 self as u8
585 }
586}
587
588#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
589pub enum ScoErrorCode {
590 Failure,
591 Cancelled,
592 InvalidArguments,
593 ParametersRejected,
594 #[doc(hidden)]
595 __SourceBreaking {
596 unknown_ordinal: u32,
597 },
598}
599
600#[macro_export]
602macro_rules! ScoErrorCodeUnknown {
603 () => {
604 _
605 };
606}
607
608impl ScoErrorCode {
609 #[inline]
610 pub fn from_primitive(prim: u32) -> Option<Self> {
611 match prim {
612 1 => Some(Self::Failure),
613 2 => Some(Self::Cancelled),
614 3 => Some(Self::InvalidArguments),
615 4 => Some(Self::ParametersRejected),
616 _ => None,
617 }
618 }
619
620 #[inline]
621 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
622 match prim {
623 1 => Self::Failure,
624 2 => Self::Cancelled,
625 3 => Self::InvalidArguments,
626 4 => Self::ParametersRejected,
627 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
628 }
629 }
630
631 #[inline]
632 pub fn unknown() -> Self {
633 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
634 }
635
636 #[inline]
637 pub const fn into_primitive(self) -> u32 {
638 match self {
639 Self::Failure => 1,
640 Self::Cancelled => 2,
641 Self::InvalidArguments => 3,
642 Self::ParametersRejected => 4,
643 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
644 }
645 }
646
647 #[inline]
648 pub fn is_unknown(&self) -> bool {
649 match self {
650 Self::__SourceBreaking { unknown_ordinal: _ } => true,
651 _ => false,
652 }
653 }
654}
655
656#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
662pub enum ServiceClassProfileIdentifier {
663 SerialPort,
665 DialupNetworking,
667 ObexObjectPush,
669 OpexFileTransfer,
671 Headset,
673 HeadsetAudioGateway,
674 HeadsetHs,
675 AudioSource,
677 AudioSink,
678 AdvancedAudioDistribution,
679 AvRemoteControlTarget,
681 AvRemoteControl,
682 AvRemoteControlController,
683 Panu,
685 Nap,
686 Gn,
687 Handsfree,
689 HandsfreeAudioGateway,
690 HumanInterfaceDevice,
692 SimAccess,
694 PhonebookPce,
696 PhonebookPse,
697 Phonebook,
698 MessageAccessServer,
700 MessageNotificationServer,
701 MessageAccessProfile,
702 MpsProfile,
704 MpsClass,
705 PnpInformation,
707 GenericNetworking,
709 GenericFileTransfer,
711 GenericAudio,
713 GenericTelephony,
715 VideoSource,
717 VideoSink,
718 VideoDistribution,
719 Hdp,
721 HdpSource,
722 HdpSink,
723 #[doc(hidden)]
724 __SourceBreaking {
725 unknown_ordinal: u16,
726 },
727}
728
729#[macro_export]
731macro_rules! ServiceClassProfileIdentifierUnknown {
732 () => {
733 _
734 };
735}
736
737impl ServiceClassProfileIdentifier {
738 #[inline]
739 pub fn from_primitive(prim: u16) -> Option<Self> {
740 match prim {
741 4353 => Some(Self::SerialPort),
742 4355 => Some(Self::DialupNetworking),
743 4357 => Some(Self::ObexObjectPush),
744 4358 => Some(Self::OpexFileTransfer),
745 4360 => Some(Self::Headset),
746 4370 => Some(Self::HeadsetAudioGateway),
747 4401 => Some(Self::HeadsetHs),
748 4362 => Some(Self::AudioSource),
749 4363 => Some(Self::AudioSink),
750 4365 => Some(Self::AdvancedAudioDistribution),
751 4364 => Some(Self::AvRemoteControlTarget),
752 4366 => Some(Self::AvRemoteControl),
753 4367 => Some(Self::AvRemoteControlController),
754 4373 => Some(Self::Panu),
755 4374 => Some(Self::Nap),
756 4375 => Some(Self::Gn),
757 4382 => Some(Self::Handsfree),
758 4383 => Some(Self::HandsfreeAudioGateway),
759 4388 => Some(Self::HumanInterfaceDevice),
760 4397 => Some(Self::SimAccess),
761 4398 => Some(Self::PhonebookPce),
762 4399 => Some(Self::PhonebookPse),
763 4400 => Some(Self::Phonebook),
764 4402 => Some(Self::MessageAccessServer),
765 4403 => Some(Self::MessageNotificationServer),
766 4404 => Some(Self::MessageAccessProfile),
767 4410 => Some(Self::MpsProfile),
768 4411 => Some(Self::MpsClass),
769 4608 => Some(Self::PnpInformation),
770 4609 => Some(Self::GenericNetworking),
771 4610 => Some(Self::GenericFileTransfer),
772 4611 => Some(Self::GenericAudio),
773 4612 => Some(Self::GenericTelephony),
774 4867 => Some(Self::VideoSource),
775 4868 => Some(Self::VideoSink),
776 4869 => Some(Self::VideoDistribution),
777 5120 => Some(Self::Hdp),
778 5121 => Some(Self::HdpSource),
779 5122 => Some(Self::HdpSink),
780 _ => None,
781 }
782 }
783
784 #[inline]
785 pub fn from_primitive_allow_unknown(prim: u16) -> Self {
786 match prim {
787 4353 => Self::SerialPort,
788 4355 => Self::DialupNetworking,
789 4357 => Self::ObexObjectPush,
790 4358 => Self::OpexFileTransfer,
791 4360 => Self::Headset,
792 4370 => Self::HeadsetAudioGateway,
793 4401 => Self::HeadsetHs,
794 4362 => Self::AudioSource,
795 4363 => Self::AudioSink,
796 4365 => Self::AdvancedAudioDistribution,
797 4364 => Self::AvRemoteControlTarget,
798 4366 => Self::AvRemoteControl,
799 4367 => Self::AvRemoteControlController,
800 4373 => Self::Panu,
801 4374 => Self::Nap,
802 4375 => Self::Gn,
803 4382 => Self::Handsfree,
804 4383 => Self::HandsfreeAudioGateway,
805 4388 => Self::HumanInterfaceDevice,
806 4397 => Self::SimAccess,
807 4398 => Self::PhonebookPce,
808 4399 => Self::PhonebookPse,
809 4400 => Self::Phonebook,
810 4402 => Self::MessageAccessServer,
811 4403 => Self::MessageNotificationServer,
812 4404 => Self::MessageAccessProfile,
813 4410 => Self::MpsProfile,
814 4411 => Self::MpsClass,
815 4608 => Self::PnpInformation,
816 4609 => Self::GenericNetworking,
817 4610 => Self::GenericFileTransfer,
818 4611 => Self::GenericAudio,
819 4612 => Self::GenericTelephony,
820 4867 => Self::VideoSource,
821 4868 => Self::VideoSink,
822 4869 => Self::VideoDistribution,
823 5120 => Self::Hdp,
824 5121 => Self::HdpSource,
825 5122 => Self::HdpSink,
826 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
827 }
828 }
829
830 #[inline]
831 pub fn unknown() -> Self {
832 Self::__SourceBreaking { unknown_ordinal: 0xffff }
833 }
834
835 #[inline]
836 pub const fn into_primitive(self) -> u16 {
837 match self {
838 Self::SerialPort => 4353,
839 Self::DialupNetworking => 4355,
840 Self::ObexObjectPush => 4357,
841 Self::OpexFileTransfer => 4358,
842 Self::Headset => 4360,
843 Self::HeadsetAudioGateway => 4370,
844 Self::HeadsetHs => 4401,
845 Self::AudioSource => 4362,
846 Self::AudioSink => 4363,
847 Self::AdvancedAudioDistribution => 4365,
848 Self::AvRemoteControlTarget => 4364,
849 Self::AvRemoteControl => 4366,
850 Self::AvRemoteControlController => 4367,
851 Self::Panu => 4373,
852 Self::Nap => 4374,
853 Self::Gn => 4375,
854 Self::Handsfree => 4382,
855 Self::HandsfreeAudioGateway => 4383,
856 Self::HumanInterfaceDevice => 4388,
857 Self::SimAccess => 4397,
858 Self::PhonebookPce => 4398,
859 Self::PhonebookPse => 4399,
860 Self::Phonebook => 4400,
861 Self::MessageAccessServer => 4402,
862 Self::MessageNotificationServer => 4403,
863 Self::MessageAccessProfile => 4404,
864 Self::MpsProfile => 4410,
865 Self::MpsClass => 4411,
866 Self::PnpInformation => 4608,
867 Self::GenericNetworking => 4609,
868 Self::GenericFileTransfer => 4610,
869 Self::GenericAudio => 4611,
870 Self::GenericTelephony => 4612,
871 Self::VideoSource => 4867,
872 Self::VideoSink => 4868,
873 Self::VideoDistribution => 4869,
874 Self::Hdp => 5120,
875 Self::HdpSource => 5121,
876 Self::HdpSink => 5122,
877 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
878 }
879 }
880
881 #[inline]
882 pub fn is_unknown(&self) -> bool {
883 match self {
884 Self::__SourceBreaking { unknown_ordinal: _ } => true,
885 _ => false,
886 }
887 }
888}
889
890#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
891pub struct AudioDirectionExtSetPriorityRequest {
892 pub priority: A2dpDirectionPriority,
893}
894
895impl fidl::Persistable for AudioDirectionExtSetPriorityRequest {}
896
897#[derive(Clone, Debug, PartialEq)]
898pub struct L2capParametersExtRequestParametersRequest {
899 pub request: fidl_fuchsia_bluetooth__common::ChannelParameters,
900}
901
902impl fidl::Persistable for L2capParametersExtRequestParametersRequest {}
903
904#[derive(Clone, Debug, PartialEq)]
905pub struct L2capParametersExtRequestParametersResponse {
906 pub new: fidl_fuchsia_bluetooth__common::ChannelParameters,
907}
908
909impl fidl::Persistable for L2capParametersExtRequestParametersResponse {}
910
911#[derive(Clone, Debug, PartialEq)]
912pub struct ProfileConnectRequest {
913 pub peer_id: fidl_fuchsia_bluetooth__common::PeerId,
914 pub connection: ConnectParameters,
915}
916
917impl fidl::Persistable for ProfileConnectRequest {}
918
919#[derive(Clone, Debug, PartialEq)]
920pub struct SearchResultsServiceFoundRequest {
921 pub peer_id: fidl_fuchsia_bluetooth__common::PeerId,
922 pub protocol: Option<Vec<ProtocolDescriptor>>,
923 pub attributes: Vec<Attribute>,
924}
925
926impl fidl::Persistable for SearchResultsServiceFoundRequest {}
927
928#[derive(Clone, Debug, Default, PartialEq)]
930pub struct Attribute {
931 pub id: Option<u16>,
933 pub element: Option<DataElement>,
935 #[doc(hidden)]
936 pub __source_breaking: fidl::marker::SourceBreaking,
937}
938
939impl fidl::Persistable for Attribute {}
940
941#[derive(Clone, Debug, Default, PartialEq)]
942pub struct AudioAacSupport {
943 #[doc(hidden)]
944 pub __source_breaking: fidl::marker::SourceBreaking,
945}
946
947impl fidl::Persistable for AudioAacSupport {}
948
949#[derive(Clone, Debug, Default, PartialEq)]
950pub struct AudioOffloadConfiguration {
951 pub codec: Option<AudioOffloadFeatures>,
952 pub max_latency: Option<u16>,
953 pub scms_t_enable: Option<bool>,
954 pub sampling_frequency: Option<AudioSamplingFrequency>,
955 pub bits_per_sample: Option<AudioBitsPerSample>,
956 pub channel_mode: Option<AudioChannelMode>,
957 pub encoded_bit_rate: Option<u32>,
958 pub encoder_settings: Option<AudioEncoderSettings>,
959 #[doc(hidden)]
960 pub __source_breaking: fidl::marker::SourceBreaking,
961}
962
963impl fidl::Persistable for AudioOffloadConfiguration {}
964
965#[derive(Clone, Debug, Default, PartialEq)]
966pub struct AudioOffloadExtGetSupportedFeaturesResponse {
967 pub audio_offload_features: Option<Vec<AudioOffloadFeatures>>,
968 #[doc(hidden)]
969 pub __source_breaking: fidl::marker::SourceBreaking,
970}
971
972impl fidl::Persistable for AudioOffloadExtGetSupportedFeaturesResponse {}
973
974#[derive(Clone, Debug, Default, PartialEq)]
975pub struct AudioSbcSupport {
976 #[doc(hidden)]
977 pub __source_breaking: fidl::marker::SourceBreaking,
978}
979
980impl fidl::Persistable for AudioSbcSupport {}
981
982#[derive(Clone, Debug, Default, PartialEq)]
985pub struct Information {
986 pub language: Option<String>,
990 pub name: Option<String>,
992 pub description: Option<String>,
994 pub provider: Option<String>,
996 #[doc(hidden)]
997 pub __source_breaking: fidl::marker::SourceBreaking,
998}
999
1000impl fidl::Persistable for Information {}
1001
1002#[derive(Clone, Debug, Default, PartialEq)]
1004pub struct L2capParameters {
1005 pub psm: Option<u16>,
1007 pub parameters: Option<fidl_fuchsia_bluetooth__common::ChannelParameters>,
1009 #[doc(hidden)]
1010 pub __source_breaking: fidl::marker::SourceBreaking,
1011}
1012
1013impl fidl::Persistable for L2capParameters {}
1014
1015#[derive(Clone, Debug, Default, PartialEq)]
1018pub struct ProfileDescriptor {
1019 pub profile_id: Option<ServiceClassProfileIdentifier>,
1021 pub major_version: Option<u8>,
1023 pub minor_version: Option<u8>,
1025 #[doc(hidden)]
1026 pub __source_breaking: fidl::marker::SourceBreaking,
1027}
1028
1029impl fidl::Persistable for ProfileDescriptor {}
1030
1031#[derive(Clone, Debug, Default, PartialEq)]
1032pub struct ProfileAdvertiseResponse {
1033 pub services: Option<Vec<ServiceDefinition>>,
1036 #[doc(hidden)]
1037 pub __source_breaking: fidl::marker::SourceBreaking,
1038}
1039
1040impl fidl::Persistable for ProfileAdvertiseResponse {}
1041
1042#[derive(Clone, Debug, Default, PartialEq)]
1047pub struct ProtocolDescriptor {
1048 pub protocol: Option<ProtocolIdentifier>,
1050 pub params: Option<Vec<DataElement>>,
1052 #[doc(hidden)]
1053 pub __source_breaking: fidl::marker::SourceBreaking,
1054}
1055
1056impl fidl::Persistable for ProtocolDescriptor {}
1057
1058#[derive(Clone, Debug, Default, PartialEq)]
1060pub struct RfcommParameters {
1061 pub channel: Option<u8>,
1063 #[doc(hidden)]
1064 pub __source_breaking: fidl::marker::SourceBreaking,
1065}
1066
1067impl fidl::Persistable for RfcommParameters {}
1068
1069#[derive(Clone, Debug, Default, PartialEq)]
1070pub struct ScoConnectionParameters {
1071 pub parameter_set: Option<HfpParameterSet>,
1074 pub air_coding_format: Option<fidl_fuchsia_bluetooth__common::AssignedCodingFormat>,
1077 pub air_frame_size: Option<u16>,
1080 pub io_bandwidth: Option<u32>,
1083 pub io_coding_format: Option<fidl_fuchsia_bluetooth__common::AssignedCodingFormat>,
1086 pub io_frame_size: Option<u16>,
1089 pub io_pcm_data_format: Option<fidl_fuchsia_hardware_audio__common::SampleFormat>,
1095 pub io_pcm_sample_payload_msb_position: Option<u8>,
1101 pub path: Option<DataPath>,
1104 pub max_tx_data_size: Option<u16>,
1108 #[doc(hidden)]
1109 pub __source_breaking: fidl::marker::SourceBreaking,
1110}
1111
1112impl fidl::Persistable for ScoConnectionParameters {}
1113
1114#[derive(Clone, Debug, Default, PartialEq)]
1115pub struct ScoConnectionWriteRequest {
1116 pub data: Option<Vec<u8>>,
1117 #[doc(hidden)]
1118 pub __source_breaking: fidl::marker::SourceBreaking,
1119}
1120
1121impl fidl::Persistable for ScoConnectionWriteRequest {}
1122
1123#[derive(Clone, Debug, Default, PartialEq)]
1124pub struct ScoConnectionReadResponse {
1125 pub status_flag: Option<RxPacketStatus>,
1126 pub data: Option<Vec<u8>>,
1127 #[doc(hidden)]
1128 pub __source_breaking: fidl::marker::SourceBreaking,
1129}
1130
1131impl fidl::Persistable for ScoConnectionReadResponse {}
1132
1133#[derive(Clone, Debug, Default, PartialEq)]
1135pub struct ServiceDefinition {
1136 pub service_class_uuids: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
1139 pub protocol_descriptor_list: Option<Vec<ProtocolDescriptor>>,
1143 pub additional_protocol_descriptor_lists: Option<Vec<Vec<ProtocolDescriptor>>>,
1146 pub profile_descriptors: Option<Vec<ProfileDescriptor>>,
1148 pub information: Option<Vec<Information>>,
1151 pub additional_attributes: Option<Vec<Attribute>>,
1155 #[doc(hidden)]
1156 pub __source_breaking: fidl::marker::SourceBreaking,
1157}
1158
1159impl fidl::Persistable for ServiceDefinition {}
1160
1161#[derive(Clone, Debug)]
1162pub enum AudioEncoderSettings {
1163 Sbc(fidl_fuchsia_media__common::SbcEncoderSettings),
1164 Aac(fidl_fuchsia_media__common::AacEncoderSettings),
1165 #[doc(hidden)]
1166 __SourceBreaking {
1167 unknown_ordinal: u64,
1168 },
1169}
1170
1171#[macro_export]
1173macro_rules! AudioEncoderSettingsUnknown {
1174 () => {
1175 _
1176 };
1177}
1178
1179impl PartialEq for AudioEncoderSettings {
1181 fn eq(&self, other: &Self) -> bool {
1182 match (self, other) {
1183 (Self::Sbc(x), Self::Sbc(y)) => *x == *y,
1184 (Self::Aac(x), Self::Aac(y)) => *x == *y,
1185 _ => false,
1186 }
1187 }
1188}
1189
1190impl AudioEncoderSettings {
1191 #[inline]
1192 pub fn ordinal(&self) -> u64 {
1193 match *self {
1194 Self::Sbc(_) => 1,
1195 Self::Aac(_) => 2,
1196 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1197 }
1198 }
1199
1200 #[inline]
1201 pub fn unknown_variant_for_testing() -> Self {
1202 Self::__SourceBreaking { unknown_ordinal: 0 }
1203 }
1204
1205 #[inline]
1206 pub fn is_unknown(&self) -> bool {
1207 match self {
1208 Self::__SourceBreaking { .. } => true,
1209 _ => false,
1210 }
1211 }
1212}
1213
1214impl fidl::Persistable for AudioEncoderSettings {}
1215
1216#[derive(Clone, Debug)]
1218pub enum AudioOffloadFeatures {
1219 Sbc(AudioSbcSupport),
1220 Aac(AudioAacSupport),
1221 #[doc(hidden)]
1222 __SourceBreaking {
1223 unknown_ordinal: u64,
1224 },
1225}
1226
1227#[macro_export]
1229macro_rules! AudioOffloadFeaturesUnknown {
1230 () => {
1231 _
1232 };
1233}
1234
1235impl PartialEq for AudioOffloadFeatures {
1237 fn eq(&self, other: &Self) -> bool {
1238 match (self, other) {
1239 (Self::Sbc(x), Self::Sbc(y)) => *x == *y,
1240 (Self::Aac(x), Self::Aac(y)) => *x == *y,
1241 _ => false,
1242 }
1243 }
1244}
1245
1246impl AudioOffloadFeatures {
1247 #[inline]
1248 pub fn ordinal(&self) -> u64 {
1249 match *self {
1250 Self::Sbc(_) => 1,
1251 Self::Aac(_) => 2,
1252 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1253 }
1254 }
1255
1256 #[inline]
1257 pub fn unknown_variant_for_testing() -> Self {
1258 Self::__SourceBreaking { unknown_ordinal: 0 }
1259 }
1260
1261 #[inline]
1262 pub fn is_unknown(&self) -> bool {
1263 match self {
1264 Self::__SourceBreaking { .. } => true,
1265 _ => false,
1266 }
1267 }
1268}
1269
1270impl fidl::Persistable for AudioOffloadFeatures {}
1271
1272#[derive(Clone, Debug, PartialEq)]
1274pub enum ConnectParameters {
1275 L2cap(L2capParameters),
1277 Rfcomm(RfcommParameters),
1279}
1280
1281impl ConnectParameters {
1282 #[inline]
1283 pub fn ordinal(&self) -> u64 {
1284 match *self {
1285 Self::L2cap(_) => 1,
1286 Self::Rfcomm(_) => 2,
1287 }
1288 }
1289}
1290
1291impl fidl::Persistable for ConnectParameters {}
1292
1293#[derive(Clone, Debug)]
1296pub enum DataElement {
1297 Int8(i8),
1298 Int16(i16),
1299 Int32(i32),
1300 Int64(i64),
1301 Uint8(u8),
1302 Uint16(u16),
1303 Uint32(u32),
1304 Uint64(u64),
1305 Str(Vec<u8>),
1306 Url(String),
1307 Uuid(fidl_fuchsia_bluetooth__common::Uuid),
1308 B(bool),
1309 Sequence(Vec<Option<Box<DataElement>>>),
1310 Alternatives(Vec<Option<Box<DataElement>>>),
1311 #[doc(hidden)]
1312 __SourceBreaking {
1313 unknown_ordinal: u64,
1314 },
1315}
1316
1317#[macro_export]
1319macro_rules! DataElementUnknown {
1320 () => {
1321 _
1322 };
1323}
1324
1325impl PartialEq for DataElement {
1327 fn eq(&self, other: &Self) -> bool {
1328 match (self, other) {
1329 (Self::Int8(x), Self::Int8(y)) => *x == *y,
1330 (Self::Int16(x), Self::Int16(y)) => *x == *y,
1331 (Self::Int32(x), Self::Int32(y)) => *x == *y,
1332 (Self::Int64(x), Self::Int64(y)) => *x == *y,
1333 (Self::Uint8(x), Self::Uint8(y)) => *x == *y,
1334 (Self::Uint16(x), Self::Uint16(y)) => *x == *y,
1335 (Self::Uint32(x), Self::Uint32(y)) => *x == *y,
1336 (Self::Uint64(x), Self::Uint64(y)) => *x == *y,
1337 (Self::Str(x), Self::Str(y)) => *x == *y,
1338 (Self::Url(x), Self::Url(y)) => *x == *y,
1339 (Self::Uuid(x), Self::Uuid(y)) => *x == *y,
1340 (Self::B(x), Self::B(y)) => *x == *y,
1341 (Self::Sequence(x), Self::Sequence(y)) => *x == *y,
1342 (Self::Alternatives(x), Self::Alternatives(y)) => *x == *y,
1343 _ => false,
1344 }
1345 }
1346}
1347
1348impl DataElement {
1349 #[inline]
1350 pub fn ordinal(&self) -> u64 {
1351 match *self {
1352 Self::Int8(_) => 1,
1353 Self::Int16(_) => 2,
1354 Self::Int32(_) => 3,
1355 Self::Int64(_) => 4,
1356 Self::Uint8(_) => 5,
1357 Self::Uint16(_) => 6,
1358 Self::Uint32(_) => 7,
1359 Self::Uint64(_) => 8,
1360 Self::Str(_) => 9,
1361 Self::Url(_) => 10,
1362 Self::Uuid(_) => 11,
1363 Self::B(_) => 12,
1364 Self::Sequence(_) => 13,
1365 Self::Alternatives(_) => 14,
1366 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1367 }
1368 }
1369
1370 #[inline]
1371 pub fn unknown_variant_for_testing() -> Self {
1372 Self::__SourceBreaking { unknown_ordinal: 0 }
1373 }
1374
1375 #[inline]
1376 pub fn is_unknown(&self) -> bool {
1377 match self {
1378 Self::__SourceBreaking { .. } => true,
1379 _ => false,
1380 }
1381 }
1382}
1383
1384impl fidl::Persistable for DataElement {}
1385
1386#[derive(Clone, Debug)]
1387pub enum ScoConnectionOnConnectionCompleteRequest {
1388 ConnectedParams(ScoConnectionParameters),
1390 Error(ScoErrorCode),
1392 #[doc(hidden)]
1393 __SourceBreaking { unknown_ordinal: u64 },
1394}
1395
1396#[macro_export]
1398macro_rules! ScoConnectionOnConnectionCompleteRequestUnknown {
1399 () => {
1400 _
1401 };
1402}
1403
1404impl PartialEq for ScoConnectionOnConnectionCompleteRequest {
1406 fn eq(&self, other: &Self) -> bool {
1407 match (self, other) {
1408 (Self::ConnectedParams(x), Self::ConnectedParams(y)) => *x == *y,
1409 (Self::Error(x), Self::Error(y)) => *x == *y,
1410 _ => false,
1411 }
1412 }
1413}
1414
1415impl ScoConnectionOnConnectionCompleteRequest {
1416 #[inline]
1417 pub fn ordinal(&self) -> u64 {
1418 match *self {
1419 Self::ConnectedParams(_) => 1,
1420 Self::Error(_) => 2,
1421 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1422 }
1423 }
1424
1425 #[inline]
1426 pub fn unknown_variant_for_testing() -> Self {
1427 Self::__SourceBreaking { unknown_ordinal: 0 }
1428 }
1429
1430 #[inline]
1431 pub fn is_unknown(&self) -> bool {
1432 match self {
1433 Self::__SourceBreaking { .. } => true,
1434 _ => false,
1435 }
1436 }
1437}
1438
1439impl fidl::Persistable for ScoConnectionOnConnectionCompleteRequest {}
1440
1441mod internal {
1442 use super::*;
1443 unsafe impl fidl::encoding::TypeMarker for A2dpDirectionPriority {
1444 type Owned = Self;
1445
1446 #[inline(always)]
1447 fn inline_align(_context: fidl::encoding::Context) -> usize {
1448 std::mem::align_of::<u32>()
1449 }
1450
1451 #[inline(always)]
1452 fn inline_size(_context: fidl::encoding::Context) -> usize {
1453 std::mem::size_of::<u32>()
1454 }
1455
1456 #[inline(always)]
1457 fn encode_is_copy() -> bool {
1458 true
1459 }
1460
1461 #[inline(always)]
1462 fn decode_is_copy() -> bool {
1463 false
1464 }
1465 }
1466
1467 impl fidl::encoding::ValueTypeMarker for A2dpDirectionPriority {
1468 type Borrowed<'a> = Self;
1469 #[inline(always)]
1470 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1471 *value
1472 }
1473 }
1474
1475 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1476 for A2dpDirectionPriority
1477 {
1478 #[inline]
1479 unsafe fn encode(
1480 self,
1481 encoder: &mut fidl::encoding::Encoder<'_, D>,
1482 offset: usize,
1483 _depth: fidl::encoding::Depth,
1484 ) -> fidl::Result<()> {
1485 encoder.debug_check_bounds::<Self>(offset);
1486 encoder.write_num(self.into_primitive(), offset);
1487 Ok(())
1488 }
1489 }
1490
1491 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for A2dpDirectionPriority {
1492 #[inline(always)]
1493 fn new_empty() -> Self {
1494 Self::Normal
1495 }
1496
1497 #[inline]
1498 unsafe fn decode(
1499 &mut self,
1500 decoder: &mut fidl::encoding::Decoder<'_, D>,
1501 offset: usize,
1502 _depth: fidl::encoding::Depth,
1503 ) -> fidl::Result<()> {
1504 decoder.debug_check_bounds::<Self>(offset);
1505 let prim = decoder.read_num::<u32>(offset);
1506
1507 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1508 Ok(())
1509 }
1510 }
1511 unsafe impl fidl::encoding::TypeMarker for AudioBitsPerSample {
1512 type Owned = Self;
1513
1514 #[inline(always)]
1515 fn inline_align(_context: fidl::encoding::Context) -> usize {
1516 std::mem::align_of::<u8>()
1517 }
1518
1519 #[inline(always)]
1520 fn inline_size(_context: fidl::encoding::Context) -> usize {
1521 std::mem::size_of::<u8>()
1522 }
1523
1524 #[inline(always)]
1525 fn encode_is_copy() -> bool {
1526 false
1527 }
1528
1529 #[inline(always)]
1530 fn decode_is_copy() -> bool {
1531 false
1532 }
1533 }
1534
1535 impl fidl::encoding::ValueTypeMarker for AudioBitsPerSample {
1536 type Borrowed<'a> = Self;
1537 #[inline(always)]
1538 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1539 *value
1540 }
1541 }
1542
1543 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1544 for AudioBitsPerSample
1545 {
1546 #[inline]
1547 unsafe fn encode(
1548 self,
1549 encoder: &mut fidl::encoding::Encoder<'_, D>,
1550 offset: usize,
1551 _depth: fidl::encoding::Depth,
1552 ) -> fidl::Result<()> {
1553 encoder.debug_check_bounds::<Self>(offset);
1554 encoder.write_num(self.into_primitive(), offset);
1555 Ok(())
1556 }
1557 }
1558
1559 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioBitsPerSample {
1560 #[inline(always)]
1561 fn new_empty() -> Self {
1562 Self::unknown()
1563 }
1564
1565 #[inline]
1566 unsafe fn decode(
1567 &mut self,
1568 decoder: &mut fidl::encoding::Decoder<'_, D>,
1569 offset: usize,
1570 _depth: fidl::encoding::Depth,
1571 ) -> fidl::Result<()> {
1572 decoder.debug_check_bounds::<Self>(offset);
1573 let prim = decoder.read_num::<u8>(offset);
1574
1575 *self = Self::from_primitive_allow_unknown(prim);
1576 Ok(())
1577 }
1578 }
1579 unsafe impl fidl::encoding::TypeMarker for AudioChannelMode {
1580 type Owned = Self;
1581
1582 #[inline(always)]
1583 fn inline_align(_context: fidl::encoding::Context) -> usize {
1584 std::mem::align_of::<u8>()
1585 }
1586
1587 #[inline(always)]
1588 fn inline_size(_context: fidl::encoding::Context) -> usize {
1589 std::mem::size_of::<u8>()
1590 }
1591
1592 #[inline(always)]
1593 fn encode_is_copy() -> bool {
1594 false
1595 }
1596
1597 #[inline(always)]
1598 fn decode_is_copy() -> bool {
1599 false
1600 }
1601 }
1602
1603 impl fidl::encoding::ValueTypeMarker for AudioChannelMode {
1604 type Borrowed<'a> = Self;
1605 #[inline(always)]
1606 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1607 *value
1608 }
1609 }
1610
1611 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1612 for AudioChannelMode
1613 {
1614 #[inline]
1615 unsafe fn encode(
1616 self,
1617 encoder: &mut fidl::encoding::Encoder<'_, D>,
1618 offset: usize,
1619 _depth: fidl::encoding::Depth,
1620 ) -> fidl::Result<()> {
1621 encoder.debug_check_bounds::<Self>(offset);
1622 encoder.write_num(self.into_primitive(), offset);
1623 Ok(())
1624 }
1625 }
1626
1627 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioChannelMode {
1628 #[inline(always)]
1629 fn new_empty() -> Self {
1630 Self::unknown()
1631 }
1632
1633 #[inline]
1634 unsafe fn decode(
1635 &mut self,
1636 decoder: &mut fidl::encoding::Decoder<'_, D>,
1637 offset: usize,
1638 _depth: fidl::encoding::Depth,
1639 ) -> fidl::Result<()> {
1640 decoder.debug_check_bounds::<Self>(offset);
1641 let prim = decoder.read_num::<u8>(offset);
1642
1643 *self = Self::from_primitive_allow_unknown(prim);
1644 Ok(())
1645 }
1646 }
1647 unsafe impl fidl::encoding::TypeMarker for AudioSamplingFrequency {
1648 type Owned = Self;
1649
1650 #[inline(always)]
1651 fn inline_align(_context: fidl::encoding::Context) -> usize {
1652 std::mem::align_of::<u8>()
1653 }
1654
1655 #[inline(always)]
1656 fn inline_size(_context: fidl::encoding::Context) -> usize {
1657 std::mem::size_of::<u8>()
1658 }
1659
1660 #[inline(always)]
1661 fn encode_is_copy() -> bool {
1662 false
1663 }
1664
1665 #[inline(always)]
1666 fn decode_is_copy() -> bool {
1667 false
1668 }
1669 }
1670
1671 impl fidl::encoding::ValueTypeMarker for AudioSamplingFrequency {
1672 type Borrowed<'a> = Self;
1673 #[inline(always)]
1674 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1675 *value
1676 }
1677 }
1678
1679 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1680 for AudioSamplingFrequency
1681 {
1682 #[inline]
1683 unsafe fn encode(
1684 self,
1685 encoder: &mut fidl::encoding::Encoder<'_, D>,
1686 offset: usize,
1687 _depth: fidl::encoding::Depth,
1688 ) -> fidl::Result<()> {
1689 encoder.debug_check_bounds::<Self>(offset);
1690 encoder.write_num(self.into_primitive(), offset);
1691 Ok(())
1692 }
1693 }
1694
1695 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1696 for AudioSamplingFrequency
1697 {
1698 #[inline(always)]
1699 fn new_empty() -> Self {
1700 Self::unknown()
1701 }
1702
1703 #[inline]
1704 unsafe fn decode(
1705 &mut self,
1706 decoder: &mut fidl::encoding::Decoder<'_, D>,
1707 offset: usize,
1708 _depth: fidl::encoding::Depth,
1709 ) -> fidl::Result<()> {
1710 decoder.debug_check_bounds::<Self>(offset);
1711 let prim = decoder.read_num::<u8>(offset);
1712
1713 *self = Self::from_primitive_allow_unknown(prim);
1714 Ok(())
1715 }
1716 }
1717 unsafe impl fidl::encoding::TypeMarker for DataPath {
1718 type Owned = Self;
1719
1720 #[inline(always)]
1721 fn inline_align(_context: fidl::encoding::Context) -> usize {
1722 std::mem::align_of::<u8>()
1723 }
1724
1725 #[inline(always)]
1726 fn inline_size(_context: fidl::encoding::Context) -> usize {
1727 std::mem::size_of::<u8>()
1728 }
1729
1730 #[inline(always)]
1731 fn encode_is_copy() -> bool {
1732 true
1733 }
1734
1735 #[inline(always)]
1736 fn decode_is_copy() -> bool {
1737 false
1738 }
1739 }
1740
1741 impl fidl::encoding::ValueTypeMarker for DataPath {
1742 type Borrowed<'a> = Self;
1743 #[inline(always)]
1744 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1745 *value
1746 }
1747 }
1748
1749 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DataPath {
1750 #[inline]
1751 unsafe fn encode(
1752 self,
1753 encoder: &mut fidl::encoding::Encoder<'_, D>,
1754 offset: usize,
1755 _depth: fidl::encoding::Depth,
1756 ) -> fidl::Result<()> {
1757 encoder.debug_check_bounds::<Self>(offset);
1758 encoder.write_num(self.into_primitive(), offset);
1759 Ok(())
1760 }
1761 }
1762
1763 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataPath {
1764 #[inline(always)]
1765 fn new_empty() -> Self {
1766 Self::Host
1767 }
1768
1769 #[inline]
1770 unsafe fn decode(
1771 &mut self,
1772 decoder: &mut fidl::encoding::Decoder<'_, D>,
1773 offset: usize,
1774 _depth: fidl::encoding::Depth,
1775 ) -> fidl::Result<()> {
1776 decoder.debug_check_bounds::<Self>(offset);
1777 let prim = decoder.read_num::<u8>(offset);
1778
1779 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1780 Ok(())
1781 }
1782 }
1783 unsafe impl fidl::encoding::TypeMarker for HfpParameterSet {
1784 type Owned = Self;
1785
1786 #[inline(always)]
1787 fn inline_align(_context: fidl::encoding::Context) -> usize {
1788 std::mem::align_of::<u8>()
1789 }
1790
1791 #[inline(always)]
1792 fn inline_size(_context: fidl::encoding::Context) -> usize {
1793 std::mem::size_of::<u8>()
1794 }
1795
1796 #[inline(always)]
1797 fn encode_is_copy() -> bool {
1798 false
1799 }
1800
1801 #[inline(always)]
1802 fn decode_is_copy() -> bool {
1803 false
1804 }
1805 }
1806
1807 impl fidl::encoding::ValueTypeMarker for HfpParameterSet {
1808 type Borrowed<'a> = Self;
1809 #[inline(always)]
1810 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1811 *value
1812 }
1813 }
1814
1815 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1816 for HfpParameterSet
1817 {
1818 #[inline]
1819 unsafe fn encode(
1820 self,
1821 encoder: &mut fidl::encoding::Encoder<'_, D>,
1822 offset: usize,
1823 _depth: fidl::encoding::Depth,
1824 ) -> fidl::Result<()> {
1825 encoder.debug_check_bounds::<Self>(offset);
1826 encoder.write_num(self.into_primitive(), offset);
1827 Ok(())
1828 }
1829 }
1830
1831 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HfpParameterSet {
1832 #[inline(always)]
1833 fn new_empty() -> Self {
1834 Self::unknown()
1835 }
1836
1837 #[inline]
1838 unsafe fn decode(
1839 &mut self,
1840 decoder: &mut fidl::encoding::Decoder<'_, D>,
1841 offset: usize,
1842 _depth: fidl::encoding::Depth,
1843 ) -> fidl::Result<()> {
1844 decoder.debug_check_bounds::<Self>(offset);
1845 let prim = decoder.read_num::<u8>(offset);
1846
1847 *self = Self::from_primitive_allow_unknown(prim);
1848 Ok(())
1849 }
1850 }
1851 unsafe impl fidl::encoding::TypeMarker for ProtocolIdentifier {
1852 type Owned = Self;
1853
1854 #[inline(always)]
1855 fn inline_align(_context: fidl::encoding::Context) -> usize {
1856 std::mem::align_of::<u16>()
1857 }
1858
1859 #[inline(always)]
1860 fn inline_size(_context: fidl::encoding::Context) -> usize {
1861 std::mem::size_of::<u16>()
1862 }
1863
1864 #[inline(always)]
1865 fn encode_is_copy() -> bool {
1866 false
1867 }
1868
1869 #[inline(always)]
1870 fn decode_is_copy() -> bool {
1871 false
1872 }
1873 }
1874
1875 impl fidl::encoding::ValueTypeMarker for ProtocolIdentifier {
1876 type Borrowed<'a> = Self;
1877 #[inline(always)]
1878 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1879 *value
1880 }
1881 }
1882
1883 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1884 for ProtocolIdentifier
1885 {
1886 #[inline]
1887 unsafe fn encode(
1888 self,
1889 encoder: &mut fidl::encoding::Encoder<'_, D>,
1890 offset: usize,
1891 _depth: fidl::encoding::Depth,
1892 ) -> fidl::Result<()> {
1893 encoder.debug_check_bounds::<Self>(offset);
1894 encoder.write_num(self.into_primitive(), offset);
1895 Ok(())
1896 }
1897 }
1898
1899 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolIdentifier {
1900 #[inline(always)]
1901 fn new_empty() -> Self {
1902 Self::unknown()
1903 }
1904
1905 #[inline]
1906 unsafe fn decode(
1907 &mut self,
1908 decoder: &mut fidl::encoding::Decoder<'_, D>,
1909 offset: usize,
1910 _depth: fidl::encoding::Depth,
1911 ) -> fidl::Result<()> {
1912 decoder.debug_check_bounds::<Self>(offset);
1913 let prim = decoder.read_num::<u16>(offset);
1914
1915 *self = Self::from_primitive_allow_unknown(prim);
1916 Ok(())
1917 }
1918 }
1919 unsafe impl fidl::encoding::TypeMarker for RxPacketStatus {
1920 type Owned = Self;
1921
1922 #[inline(always)]
1923 fn inline_align(_context: fidl::encoding::Context) -> usize {
1924 std::mem::align_of::<u8>()
1925 }
1926
1927 #[inline(always)]
1928 fn inline_size(_context: fidl::encoding::Context) -> usize {
1929 std::mem::size_of::<u8>()
1930 }
1931
1932 #[inline(always)]
1933 fn encode_is_copy() -> bool {
1934 true
1935 }
1936
1937 #[inline(always)]
1938 fn decode_is_copy() -> bool {
1939 false
1940 }
1941 }
1942
1943 impl fidl::encoding::ValueTypeMarker for RxPacketStatus {
1944 type Borrowed<'a> = Self;
1945 #[inline(always)]
1946 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1947 *value
1948 }
1949 }
1950
1951 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for RxPacketStatus {
1952 #[inline]
1953 unsafe fn encode(
1954 self,
1955 encoder: &mut fidl::encoding::Encoder<'_, D>,
1956 offset: usize,
1957 _depth: fidl::encoding::Depth,
1958 ) -> fidl::Result<()> {
1959 encoder.debug_check_bounds::<Self>(offset);
1960 encoder.write_num(self.into_primitive(), offset);
1961 Ok(())
1962 }
1963 }
1964
1965 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RxPacketStatus {
1966 #[inline(always)]
1967 fn new_empty() -> Self {
1968 Self::CorrectlyReceivedData
1969 }
1970
1971 #[inline]
1972 unsafe fn decode(
1973 &mut self,
1974 decoder: &mut fidl::encoding::Decoder<'_, D>,
1975 offset: usize,
1976 _depth: fidl::encoding::Depth,
1977 ) -> fidl::Result<()> {
1978 decoder.debug_check_bounds::<Self>(offset);
1979 let prim = decoder.read_num::<u8>(offset);
1980
1981 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1982 Ok(())
1983 }
1984 }
1985 unsafe impl fidl::encoding::TypeMarker for ScoErrorCode {
1986 type Owned = Self;
1987
1988 #[inline(always)]
1989 fn inline_align(_context: fidl::encoding::Context) -> usize {
1990 std::mem::align_of::<u32>()
1991 }
1992
1993 #[inline(always)]
1994 fn inline_size(_context: fidl::encoding::Context) -> usize {
1995 std::mem::size_of::<u32>()
1996 }
1997
1998 #[inline(always)]
1999 fn encode_is_copy() -> bool {
2000 false
2001 }
2002
2003 #[inline(always)]
2004 fn decode_is_copy() -> bool {
2005 false
2006 }
2007 }
2008
2009 impl fidl::encoding::ValueTypeMarker for ScoErrorCode {
2010 type Borrowed<'a> = Self;
2011 #[inline(always)]
2012 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2013 *value
2014 }
2015 }
2016
2017 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScoErrorCode {
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> for ScoErrorCode {
2032 #[inline(always)]
2033 fn new_empty() -> Self {
2034 Self::unknown()
2035 }
2036
2037 #[inline]
2038 unsafe fn decode(
2039 &mut self,
2040 decoder: &mut fidl::encoding::Decoder<'_, D>,
2041 offset: usize,
2042 _depth: fidl::encoding::Depth,
2043 ) -> fidl::Result<()> {
2044 decoder.debug_check_bounds::<Self>(offset);
2045 let prim = decoder.read_num::<u32>(offset);
2046
2047 *self = Self::from_primitive_allow_unknown(prim);
2048 Ok(())
2049 }
2050 }
2051 unsafe impl fidl::encoding::TypeMarker for ServiceClassProfileIdentifier {
2052 type Owned = Self;
2053
2054 #[inline(always)]
2055 fn inline_align(_context: fidl::encoding::Context) -> usize {
2056 std::mem::align_of::<u16>()
2057 }
2058
2059 #[inline(always)]
2060 fn inline_size(_context: fidl::encoding::Context) -> usize {
2061 std::mem::size_of::<u16>()
2062 }
2063
2064 #[inline(always)]
2065 fn encode_is_copy() -> bool {
2066 false
2067 }
2068
2069 #[inline(always)]
2070 fn decode_is_copy() -> bool {
2071 false
2072 }
2073 }
2074
2075 impl fidl::encoding::ValueTypeMarker for ServiceClassProfileIdentifier {
2076 type Borrowed<'a> = Self;
2077 #[inline(always)]
2078 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2079 *value
2080 }
2081 }
2082
2083 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2084 for ServiceClassProfileIdentifier
2085 {
2086 #[inline]
2087 unsafe fn encode(
2088 self,
2089 encoder: &mut fidl::encoding::Encoder<'_, D>,
2090 offset: usize,
2091 _depth: fidl::encoding::Depth,
2092 ) -> fidl::Result<()> {
2093 encoder.debug_check_bounds::<Self>(offset);
2094 encoder.write_num(self.into_primitive(), offset);
2095 Ok(())
2096 }
2097 }
2098
2099 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2100 for ServiceClassProfileIdentifier
2101 {
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::<u16>(offset);
2116
2117 *self = Self::from_primitive_allow_unknown(prim);
2118 Ok(())
2119 }
2120 }
2121
2122 impl fidl::encoding::ValueTypeMarker for AudioDirectionExtSetPriorityRequest {
2123 type Borrowed<'a> = &'a Self;
2124 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2125 value
2126 }
2127 }
2128
2129 unsafe impl fidl::encoding::TypeMarker for AudioDirectionExtSetPriorityRequest {
2130 type Owned = Self;
2131
2132 #[inline(always)]
2133 fn inline_align(_context: fidl::encoding::Context) -> usize {
2134 4
2135 }
2136
2137 #[inline(always)]
2138 fn inline_size(_context: fidl::encoding::Context) -> usize {
2139 4
2140 }
2141 }
2142
2143 unsafe impl<D: fidl::encoding::ResourceDialect>
2144 fidl::encoding::Encode<AudioDirectionExtSetPriorityRequest, D>
2145 for &AudioDirectionExtSetPriorityRequest
2146 {
2147 #[inline]
2148 unsafe fn encode(
2149 self,
2150 encoder: &mut fidl::encoding::Encoder<'_, D>,
2151 offset: usize,
2152 _depth: fidl::encoding::Depth,
2153 ) -> fidl::Result<()> {
2154 encoder.debug_check_bounds::<AudioDirectionExtSetPriorityRequest>(offset);
2155 fidl::encoding::Encode::<AudioDirectionExtSetPriorityRequest, D>::encode(
2157 (<A2dpDirectionPriority as fidl::encoding::ValueTypeMarker>::borrow(
2158 &self.priority,
2159 ),),
2160 encoder,
2161 offset,
2162 _depth,
2163 )
2164 }
2165 }
2166 unsafe impl<
2167 D: fidl::encoding::ResourceDialect,
2168 T0: fidl::encoding::Encode<A2dpDirectionPriority, D>,
2169 > fidl::encoding::Encode<AudioDirectionExtSetPriorityRequest, D> for (T0,)
2170 {
2171 #[inline]
2172 unsafe fn encode(
2173 self,
2174 encoder: &mut fidl::encoding::Encoder<'_, D>,
2175 offset: usize,
2176 depth: fidl::encoding::Depth,
2177 ) -> fidl::Result<()> {
2178 encoder.debug_check_bounds::<AudioDirectionExtSetPriorityRequest>(offset);
2179 self.0.encode(encoder, offset + 0, depth)?;
2183 Ok(())
2184 }
2185 }
2186
2187 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2188 for AudioDirectionExtSetPriorityRequest
2189 {
2190 #[inline(always)]
2191 fn new_empty() -> Self {
2192 Self { priority: fidl::new_empty!(A2dpDirectionPriority, D) }
2193 }
2194
2195 #[inline]
2196 unsafe fn decode(
2197 &mut self,
2198 decoder: &mut fidl::encoding::Decoder<'_, D>,
2199 offset: usize,
2200 _depth: fidl::encoding::Depth,
2201 ) -> fidl::Result<()> {
2202 decoder.debug_check_bounds::<Self>(offset);
2203 fidl::decode!(
2205 A2dpDirectionPriority,
2206 D,
2207 &mut self.priority,
2208 decoder,
2209 offset + 0,
2210 _depth
2211 )?;
2212 Ok(())
2213 }
2214 }
2215
2216 impl fidl::encoding::ValueTypeMarker for L2capParametersExtRequestParametersRequest {
2217 type Borrowed<'a> = &'a Self;
2218 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2219 value
2220 }
2221 }
2222
2223 unsafe impl fidl::encoding::TypeMarker for L2capParametersExtRequestParametersRequest {
2224 type Owned = Self;
2225
2226 #[inline(always)]
2227 fn inline_align(_context: fidl::encoding::Context) -> usize {
2228 8
2229 }
2230
2231 #[inline(always)]
2232 fn inline_size(_context: fidl::encoding::Context) -> usize {
2233 16
2234 }
2235 }
2236
2237 unsafe impl<D: fidl::encoding::ResourceDialect>
2238 fidl::encoding::Encode<L2capParametersExtRequestParametersRequest, D>
2239 for &L2capParametersExtRequestParametersRequest
2240 {
2241 #[inline]
2242 unsafe fn encode(
2243 self,
2244 encoder: &mut fidl::encoding::Encoder<'_, D>,
2245 offset: usize,
2246 _depth: fidl::encoding::Depth,
2247 ) -> fidl::Result<()> {
2248 encoder.debug_check_bounds::<L2capParametersExtRequestParametersRequest>(offset);
2249 fidl::encoding::Encode::<L2capParametersExtRequestParametersRequest, D>::encode(
2251 (
2252 <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.request),
2253 ),
2254 encoder, offset, _depth
2255 )
2256 }
2257 }
2258 unsafe impl<
2259 D: fidl::encoding::ResourceDialect,
2260 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::ChannelParameters, D>,
2261 > fidl::encoding::Encode<L2capParametersExtRequestParametersRequest, D> for (T0,)
2262 {
2263 #[inline]
2264 unsafe fn encode(
2265 self,
2266 encoder: &mut fidl::encoding::Encoder<'_, D>,
2267 offset: usize,
2268 depth: fidl::encoding::Depth,
2269 ) -> fidl::Result<()> {
2270 encoder.debug_check_bounds::<L2capParametersExtRequestParametersRequest>(offset);
2271 self.0.encode(encoder, offset + 0, depth)?;
2275 Ok(())
2276 }
2277 }
2278
2279 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2280 for L2capParametersExtRequestParametersRequest
2281 {
2282 #[inline(always)]
2283 fn new_empty() -> Self {
2284 Self { request: fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D) }
2285 }
2286
2287 #[inline]
2288 unsafe fn decode(
2289 &mut self,
2290 decoder: &mut fidl::encoding::Decoder<'_, D>,
2291 offset: usize,
2292 _depth: fidl::encoding::Depth,
2293 ) -> fidl::Result<()> {
2294 decoder.debug_check_bounds::<Self>(offset);
2295 fidl::decode!(
2297 fidl_fuchsia_bluetooth__common::ChannelParameters,
2298 D,
2299 &mut self.request,
2300 decoder,
2301 offset + 0,
2302 _depth
2303 )?;
2304 Ok(())
2305 }
2306 }
2307
2308 impl fidl::encoding::ValueTypeMarker for L2capParametersExtRequestParametersResponse {
2309 type Borrowed<'a> = &'a Self;
2310 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2311 value
2312 }
2313 }
2314
2315 unsafe impl fidl::encoding::TypeMarker for L2capParametersExtRequestParametersResponse {
2316 type Owned = Self;
2317
2318 #[inline(always)]
2319 fn inline_align(_context: fidl::encoding::Context) -> usize {
2320 8
2321 }
2322
2323 #[inline(always)]
2324 fn inline_size(_context: fidl::encoding::Context) -> usize {
2325 16
2326 }
2327 }
2328
2329 unsafe impl<D: fidl::encoding::ResourceDialect>
2330 fidl::encoding::Encode<L2capParametersExtRequestParametersResponse, D>
2331 for &L2capParametersExtRequestParametersResponse
2332 {
2333 #[inline]
2334 unsafe fn encode(
2335 self,
2336 encoder: &mut fidl::encoding::Encoder<'_, D>,
2337 offset: usize,
2338 _depth: fidl::encoding::Depth,
2339 ) -> fidl::Result<()> {
2340 encoder.debug_check_bounds::<L2capParametersExtRequestParametersResponse>(offset);
2341 fidl::encoding::Encode::<L2capParametersExtRequestParametersResponse, D>::encode(
2343 (
2344 <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.new),
2345 ),
2346 encoder, offset, _depth
2347 )
2348 }
2349 }
2350 unsafe impl<
2351 D: fidl::encoding::ResourceDialect,
2352 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::ChannelParameters, D>,
2353 > fidl::encoding::Encode<L2capParametersExtRequestParametersResponse, D> for (T0,)
2354 {
2355 #[inline]
2356 unsafe fn encode(
2357 self,
2358 encoder: &mut fidl::encoding::Encoder<'_, D>,
2359 offset: usize,
2360 depth: fidl::encoding::Depth,
2361 ) -> fidl::Result<()> {
2362 encoder.debug_check_bounds::<L2capParametersExtRequestParametersResponse>(offset);
2363 self.0.encode(encoder, offset + 0, depth)?;
2367 Ok(())
2368 }
2369 }
2370
2371 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2372 for L2capParametersExtRequestParametersResponse
2373 {
2374 #[inline(always)]
2375 fn new_empty() -> Self {
2376 Self { new: fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D) }
2377 }
2378
2379 #[inline]
2380 unsafe fn decode(
2381 &mut self,
2382 decoder: &mut fidl::encoding::Decoder<'_, D>,
2383 offset: usize,
2384 _depth: fidl::encoding::Depth,
2385 ) -> fidl::Result<()> {
2386 decoder.debug_check_bounds::<Self>(offset);
2387 fidl::decode!(
2389 fidl_fuchsia_bluetooth__common::ChannelParameters,
2390 D,
2391 &mut self.new,
2392 decoder,
2393 offset + 0,
2394 _depth
2395 )?;
2396 Ok(())
2397 }
2398 }
2399
2400 impl fidl::encoding::ValueTypeMarker for ProfileConnectRequest {
2401 type Borrowed<'a> = &'a Self;
2402 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2403 value
2404 }
2405 }
2406
2407 unsafe impl fidl::encoding::TypeMarker for ProfileConnectRequest {
2408 type Owned = Self;
2409
2410 #[inline(always)]
2411 fn inline_align(_context: fidl::encoding::Context) -> usize {
2412 8
2413 }
2414
2415 #[inline(always)]
2416 fn inline_size(_context: fidl::encoding::Context) -> usize {
2417 24
2418 }
2419 }
2420
2421 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProfileConnectRequest, D>
2422 for &ProfileConnectRequest
2423 {
2424 #[inline]
2425 unsafe fn encode(
2426 self,
2427 encoder: &mut fidl::encoding::Encoder<'_, D>,
2428 offset: usize,
2429 _depth: fidl::encoding::Depth,
2430 ) -> fidl::Result<()> {
2431 encoder.debug_check_bounds::<ProfileConnectRequest>(offset);
2432 fidl::encoding::Encode::<ProfileConnectRequest, D>::encode(
2434 (
2435 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
2436 <ConnectParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.connection),
2437 ),
2438 encoder, offset, _depth
2439 )
2440 }
2441 }
2442 unsafe impl<
2443 D: fidl::encoding::ResourceDialect,
2444 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2445 T1: fidl::encoding::Encode<ConnectParameters, D>,
2446 > fidl::encoding::Encode<ProfileConnectRequest, D> for (T0, T1)
2447 {
2448 #[inline]
2449 unsafe fn encode(
2450 self,
2451 encoder: &mut fidl::encoding::Encoder<'_, D>,
2452 offset: usize,
2453 depth: fidl::encoding::Depth,
2454 ) -> fidl::Result<()> {
2455 encoder.debug_check_bounds::<ProfileConnectRequest>(offset);
2456 self.0.encode(encoder, offset + 0, depth)?;
2460 self.1.encode(encoder, offset + 8, depth)?;
2461 Ok(())
2462 }
2463 }
2464
2465 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProfileConnectRequest {
2466 #[inline(always)]
2467 fn new_empty() -> Self {
2468 Self {
2469 peer_id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
2470 connection: fidl::new_empty!(ConnectParameters, D),
2471 }
2472 }
2473
2474 #[inline]
2475 unsafe fn decode(
2476 &mut self,
2477 decoder: &mut fidl::encoding::Decoder<'_, D>,
2478 offset: usize,
2479 _depth: fidl::encoding::Depth,
2480 ) -> fidl::Result<()> {
2481 decoder.debug_check_bounds::<Self>(offset);
2482 fidl::decode!(
2484 fidl_fuchsia_bluetooth__common::PeerId,
2485 D,
2486 &mut self.peer_id,
2487 decoder,
2488 offset + 0,
2489 _depth
2490 )?;
2491 fidl::decode!(ConnectParameters, D, &mut self.connection, decoder, offset + 8, _depth)?;
2492 Ok(())
2493 }
2494 }
2495
2496 impl fidl::encoding::ValueTypeMarker for SearchResultsServiceFoundRequest {
2497 type Borrowed<'a> = &'a Self;
2498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2499 value
2500 }
2501 }
2502
2503 unsafe impl fidl::encoding::TypeMarker for SearchResultsServiceFoundRequest {
2504 type Owned = Self;
2505
2506 #[inline(always)]
2507 fn inline_align(_context: fidl::encoding::Context) -> usize {
2508 8
2509 }
2510
2511 #[inline(always)]
2512 fn inline_size(_context: fidl::encoding::Context) -> usize {
2513 40
2514 }
2515 }
2516
2517 unsafe impl<D: fidl::encoding::ResourceDialect>
2518 fidl::encoding::Encode<SearchResultsServiceFoundRequest, D>
2519 for &SearchResultsServiceFoundRequest
2520 {
2521 #[inline]
2522 unsafe fn encode(
2523 self,
2524 encoder: &mut fidl::encoding::Encoder<'_, D>,
2525 offset: usize,
2526 _depth: fidl::encoding::Depth,
2527 ) -> fidl::Result<()> {
2528 encoder.debug_check_bounds::<SearchResultsServiceFoundRequest>(offset);
2529 fidl::encoding::Encode::<SearchResultsServiceFoundRequest, D>::encode(
2531 (
2532 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
2533 <fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),
2534 <fidl::encoding::Vector<Attribute, 512> as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
2535 ),
2536 encoder, offset, _depth
2537 )
2538 }
2539 }
2540 unsafe impl<
2541 D: fidl::encoding::ResourceDialect,
2542 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2543 T1: fidl::encoding::Encode<
2544 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2545 D,
2546 >,
2547 T2: fidl::encoding::Encode<fidl::encoding::Vector<Attribute, 512>, D>,
2548 > fidl::encoding::Encode<SearchResultsServiceFoundRequest, D> for (T0, T1, T2)
2549 {
2550 #[inline]
2551 unsafe fn encode(
2552 self,
2553 encoder: &mut fidl::encoding::Encoder<'_, D>,
2554 offset: usize,
2555 depth: fidl::encoding::Depth,
2556 ) -> fidl::Result<()> {
2557 encoder.debug_check_bounds::<SearchResultsServiceFoundRequest>(offset);
2558 self.0.encode(encoder, offset + 0, depth)?;
2562 self.1.encode(encoder, offset + 8, depth)?;
2563 self.2.encode(encoder, offset + 24, depth)?;
2564 Ok(())
2565 }
2566 }
2567
2568 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2569 for SearchResultsServiceFoundRequest
2570 {
2571 #[inline(always)]
2572 fn new_empty() -> Self {
2573 Self {
2574 peer_id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
2575 protocol: fidl::new_empty!(
2576 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2577 D
2578 ),
2579 attributes: fidl::new_empty!(fidl::encoding::Vector<Attribute, 512>, D),
2580 }
2581 }
2582
2583 #[inline]
2584 unsafe fn decode(
2585 &mut self,
2586 decoder: &mut fidl::encoding::Decoder<'_, D>,
2587 offset: usize,
2588 _depth: fidl::encoding::Depth,
2589 ) -> fidl::Result<()> {
2590 decoder.debug_check_bounds::<Self>(offset);
2591 fidl::decode!(
2593 fidl_fuchsia_bluetooth__common::PeerId,
2594 D,
2595 &mut self.peer_id,
2596 decoder,
2597 offset + 0,
2598 _depth
2599 )?;
2600 fidl::decode!(
2601 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2602 D,
2603 &mut self.protocol,
2604 decoder,
2605 offset + 8,
2606 _depth
2607 )?;
2608 fidl::decode!(fidl::encoding::Vector<Attribute, 512>, D, &mut self.attributes, decoder, offset + 24, _depth)?;
2609 Ok(())
2610 }
2611 }
2612
2613 impl Attribute {
2614 #[inline(always)]
2615 fn max_ordinal_present(&self) -> u64 {
2616 if let Some(_) = self.element {
2617 return 2;
2618 }
2619 if let Some(_) = self.id {
2620 return 1;
2621 }
2622 0
2623 }
2624 }
2625
2626 impl fidl::encoding::ValueTypeMarker for Attribute {
2627 type Borrowed<'a> = &'a Self;
2628 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2629 value
2630 }
2631 }
2632
2633 unsafe impl fidl::encoding::TypeMarker for Attribute {
2634 type Owned = Self;
2635
2636 #[inline(always)]
2637 fn inline_align(_context: fidl::encoding::Context) -> usize {
2638 8
2639 }
2640
2641 #[inline(always)]
2642 fn inline_size(_context: fidl::encoding::Context) -> usize {
2643 16
2644 }
2645 }
2646
2647 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Attribute, D>
2648 for &Attribute
2649 {
2650 unsafe fn encode(
2651 self,
2652 encoder: &mut fidl::encoding::Encoder<'_, D>,
2653 offset: usize,
2654 mut depth: fidl::encoding::Depth,
2655 ) -> fidl::Result<()> {
2656 encoder.debug_check_bounds::<Attribute>(offset);
2657 let max_ordinal: u64 = self.max_ordinal_present();
2659 encoder.write_num(max_ordinal, offset);
2660 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2661 if max_ordinal == 0 {
2663 return Ok(());
2664 }
2665 depth.increment()?;
2666 let envelope_size = 8;
2667 let bytes_len = max_ordinal as usize * envelope_size;
2668 #[allow(unused_variables)]
2669 let offset = encoder.out_of_line_offset(bytes_len);
2670 let mut _prev_end_offset: usize = 0;
2671 if 1 > max_ordinal {
2672 return Ok(());
2673 }
2674
2675 let cur_offset: usize = (1 - 1) * envelope_size;
2678
2679 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2681
2682 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2687 self.id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2688 encoder,
2689 offset + cur_offset,
2690 depth,
2691 )?;
2692
2693 _prev_end_offset = cur_offset + envelope_size;
2694 if 2 > max_ordinal {
2695 return Ok(());
2696 }
2697
2698 let cur_offset: usize = (2 - 1) * envelope_size;
2701
2702 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2704
2705 fidl::encoding::encode_in_envelope_optional::<DataElement, D>(
2710 self.element.as_ref().map(<DataElement as fidl::encoding::ValueTypeMarker>::borrow),
2711 encoder,
2712 offset + cur_offset,
2713 depth,
2714 )?;
2715
2716 _prev_end_offset = cur_offset + envelope_size;
2717
2718 Ok(())
2719 }
2720 }
2721
2722 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Attribute {
2723 #[inline(always)]
2724 fn new_empty() -> Self {
2725 Self::default()
2726 }
2727
2728 unsafe fn decode(
2729 &mut self,
2730 decoder: &mut fidl::encoding::Decoder<'_, D>,
2731 offset: usize,
2732 mut depth: fidl::encoding::Depth,
2733 ) -> fidl::Result<()> {
2734 decoder.debug_check_bounds::<Self>(offset);
2735 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2736 None => return Err(fidl::Error::NotNullable),
2737 Some(len) => len,
2738 };
2739 if len == 0 {
2741 return Ok(());
2742 };
2743 depth.increment()?;
2744 let envelope_size = 8;
2745 let bytes_len = len * envelope_size;
2746 let offset = decoder.out_of_line_offset(bytes_len)?;
2747 let mut _next_ordinal_to_read = 0;
2749 let mut next_offset = offset;
2750 let end_offset = offset + bytes_len;
2751 _next_ordinal_to_read += 1;
2752 if next_offset >= end_offset {
2753 return Ok(());
2754 }
2755
2756 while _next_ordinal_to_read < 1 {
2758 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2759 _next_ordinal_to_read += 1;
2760 next_offset += envelope_size;
2761 }
2762
2763 let next_out_of_line = decoder.next_out_of_line();
2764 let handles_before = decoder.remaining_handles();
2765 if let Some((inlined, num_bytes, num_handles)) =
2766 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2767 {
2768 let member_inline_size =
2769 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2770 if inlined != (member_inline_size <= 4) {
2771 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2772 }
2773 let inner_offset;
2774 let mut inner_depth = depth.clone();
2775 if inlined {
2776 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2777 inner_offset = next_offset;
2778 } else {
2779 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2780 inner_depth.increment()?;
2781 }
2782 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u16, D));
2783 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2784 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2785 {
2786 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2787 }
2788 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2789 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2790 }
2791 }
2792
2793 next_offset += envelope_size;
2794 _next_ordinal_to_read += 1;
2795 if next_offset >= end_offset {
2796 return Ok(());
2797 }
2798
2799 while _next_ordinal_to_read < 2 {
2801 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2802 _next_ordinal_to_read += 1;
2803 next_offset += envelope_size;
2804 }
2805
2806 let next_out_of_line = decoder.next_out_of_line();
2807 let handles_before = decoder.remaining_handles();
2808 if let Some((inlined, num_bytes, num_handles)) =
2809 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2810 {
2811 let member_inline_size =
2812 <DataElement as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2813 if inlined != (member_inline_size <= 4) {
2814 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2815 }
2816 let inner_offset;
2817 let mut inner_depth = depth.clone();
2818 if inlined {
2819 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2820 inner_offset = next_offset;
2821 } else {
2822 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2823 inner_depth.increment()?;
2824 }
2825 let val_ref = self.element.get_or_insert_with(|| fidl::new_empty!(DataElement, D));
2826 fidl::decode!(DataElement, D, val_ref, decoder, inner_offset, inner_depth)?;
2827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2828 {
2829 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2830 }
2831 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2832 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2833 }
2834 }
2835
2836 next_offset += envelope_size;
2837
2838 while next_offset < end_offset {
2840 _next_ordinal_to_read += 1;
2841 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2842 next_offset += envelope_size;
2843 }
2844
2845 Ok(())
2846 }
2847 }
2848
2849 impl AudioAacSupport {
2850 #[inline(always)]
2851 fn max_ordinal_present(&self) -> u64 {
2852 0
2853 }
2854 }
2855
2856 impl fidl::encoding::ValueTypeMarker for AudioAacSupport {
2857 type Borrowed<'a> = &'a Self;
2858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2859 value
2860 }
2861 }
2862
2863 unsafe impl fidl::encoding::TypeMarker for AudioAacSupport {
2864 type Owned = Self;
2865
2866 #[inline(always)]
2867 fn inline_align(_context: fidl::encoding::Context) -> usize {
2868 8
2869 }
2870
2871 #[inline(always)]
2872 fn inline_size(_context: fidl::encoding::Context) -> usize {
2873 16
2874 }
2875 }
2876
2877 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioAacSupport, D>
2878 for &AudioAacSupport
2879 {
2880 unsafe fn encode(
2881 self,
2882 encoder: &mut fidl::encoding::Encoder<'_, D>,
2883 offset: usize,
2884 mut depth: fidl::encoding::Depth,
2885 ) -> fidl::Result<()> {
2886 encoder.debug_check_bounds::<AudioAacSupport>(offset);
2887 let max_ordinal: u64 = self.max_ordinal_present();
2889 encoder.write_num(max_ordinal, offset);
2890 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2891 if max_ordinal == 0 {
2893 return Ok(());
2894 }
2895 depth.increment()?;
2896 let envelope_size = 8;
2897 let bytes_len = max_ordinal as usize * envelope_size;
2898 #[allow(unused_variables)]
2899 let offset = encoder.out_of_line_offset(bytes_len);
2900 let mut _prev_end_offset: usize = 0;
2901
2902 Ok(())
2903 }
2904 }
2905
2906 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioAacSupport {
2907 #[inline(always)]
2908 fn new_empty() -> Self {
2909 Self::default()
2910 }
2911
2912 unsafe fn decode(
2913 &mut self,
2914 decoder: &mut fidl::encoding::Decoder<'_, D>,
2915 offset: usize,
2916 mut depth: fidl::encoding::Depth,
2917 ) -> fidl::Result<()> {
2918 decoder.debug_check_bounds::<Self>(offset);
2919 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2920 None => return Err(fidl::Error::NotNullable),
2921 Some(len) => len,
2922 };
2923 if len == 0 {
2925 return Ok(());
2926 };
2927 depth.increment()?;
2928 let envelope_size = 8;
2929 let bytes_len = len * envelope_size;
2930 let offset = decoder.out_of_line_offset(bytes_len)?;
2931 let mut _next_ordinal_to_read = 0;
2933 let mut next_offset = offset;
2934 let end_offset = offset + bytes_len;
2935
2936 while next_offset < end_offset {
2938 _next_ordinal_to_read += 1;
2939 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2940 next_offset += envelope_size;
2941 }
2942
2943 Ok(())
2944 }
2945 }
2946
2947 impl AudioOffloadConfiguration {
2948 #[inline(always)]
2949 fn max_ordinal_present(&self) -> u64 {
2950 if let Some(_) = self.encoder_settings {
2951 return 8;
2952 }
2953 if let Some(_) = self.encoded_bit_rate {
2954 return 7;
2955 }
2956 if let Some(_) = self.channel_mode {
2957 return 6;
2958 }
2959 if let Some(_) = self.bits_per_sample {
2960 return 5;
2961 }
2962 if let Some(_) = self.sampling_frequency {
2963 return 4;
2964 }
2965 if let Some(_) = self.scms_t_enable {
2966 return 3;
2967 }
2968 if let Some(_) = self.max_latency {
2969 return 2;
2970 }
2971 if let Some(_) = self.codec {
2972 return 1;
2973 }
2974 0
2975 }
2976 }
2977
2978 impl fidl::encoding::ValueTypeMarker for AudioOffloadConfiguration {
2979 type Borrowed<'a> = &'a Self;
2980 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2981 value
2982 }
2983 }
2984
2985 unsafe impl fidl::encoding::TypeMarker for AudioOffloadConfiguration {
2986 type Owned = Self;
2987
2988 #[inline(always)]
2989 fn inline_align(_context: fidl::encoding::Context) -> usize {
2990 8
2991 }
2992
2993 #[inline(always)]
2994 fn inline_size(_context: fidl::encoding::Context) -> usize {
2995 16
2996 }
2997 }
2998
2999 unsafe impl<D: fidl::encoding::ResourceDialect>
3000 fidl::encoding::Encode<AudioOffloadConfiguration, D> for &AudioOffloadConfiguration
3001 {
3002 unsafe fn encode(
3003 self,
3004 encoder: &mut fidl::encoding::Encoder<'_, D>,
3005 offset: usize,
3006 mut depth: fidl::encoding::Depth,
3007 ) -> fidl::Result<()> {
3008 encoder.debug_check_bounds::<AudioOffloadConfiguration>(offset);
3009 let max_ordinal: u64 = self.max_ordinal_present();
3011 encoder.write_num(max_ordinal, offset);
3012 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3013 if max_ordinal == 0 {
3015 return Ok(());
3016 }
3017 depth.increment()?;
3018 let envelope_size = 8;
3019 let bytes_len = max_ordinal as usize * envelope_size;
3020 #[allow(unused_variables)]
3021 let offset = encoder.out_of_line_offset(bytes_len);
3022 let mut _prev_end_offset: usize = 0;
3023 if 1 > max_ordinal {
3024 return Ok(());
3025 }
3026
3027 let cur_offset: usize = (1 - 1) * envelope_size;
3030
3031 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3033
3034 fidl::encoding::encode_in_envelope_optional::<AudioOffloadFeatures, D>(
3039 self.codec
3040 .as_ref()
3041 .map(<AudioOffloadFeatures as fidl::encoding::ValueTypeMarker>::borrow),
3042 encoder,
3043 offset + cur_offset,
3044 depth,
3045 )?;
3046
3047 _prev_end_offset = cur_offset + envelope_size;
3048 if 2 > max_ordinal {
3049 return Ok(());
3050 }
3051
3052 let cur_offset: usize = (2 - 1) * envelope_size;
3055
3056 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3058
3059 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3064 self.max_latency.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3065 encoder,
3066 offset + cur_offset,
3067 depth,
3068 )?;
3069
3070 _prev_end_offset = cur_offset + envelope_size;
3071 if 3 > max_ordinal {
3072 return Ok(());
3073 }
3074
3075 let cur_offset: usize = (3 - 1) * envelope_size;
3078
3079 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3081
3082 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3087 self.scms_t_enable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3088 encoder,
3089 offset + cur_offset,
3090 depth,
3091 )?;
3092
3093 _prev_end_offset = cur_offset + envelope_size;
3094 if 4 > max_ordinal {
3095 return Ok(());
3096 }
3097
3098 let cur_offset: usize = (4 - 1) * envelope_size;
3101
3102 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3104
3105 fidl::encoding::encode_in_envelope_optional::<AudioSamplingFrequency, D>(
3110 self.sampling_frequency
3111 .as_ref()
3112 .map(<AudioSamplingFrequency as fidl::encoding::ValueTypeMarker>::borrow),
3113 encoder,
3114 offset + cur_offset,
3115 depth,
3116 )?;
3117
3118 _prev_end_offset = cur_offset + envelope_size;
3119 if 5 > max_ordinal {
3120 return Ok(());
3121 }
3122
3123 let cur_offset: usize = (5 - 1) * envelope_size;
3126
3127 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3129
3130 fidl::encoding::encode_in_envelope_optional::<AudioBitsPerSample, D>(
3135 self.bits_per_sample
3136 .as_ref()
3137 .map(<AudioBitsPerSample as fidl::encoding::ValueTypeMarker>::borrow),
3138 encoder,
3139 offset + cur_offset,
3140 depth,
3141 )?;
3142
3143 _prev_end_offset = cur_offset + envelope_size;
3144 if 6 > max_ordinal {
3145 return Ok(());
3146 }
3147
3148 let cur_offset: usize = (6 - 1) * envelope_size;
3151
3152 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3154
3155 fidl::encoding::encode_in_envelope_optional::<AudioChannelMode, D>(
3160 self.channel_mode
3161 .as_ref()
3162 .map(<AudioChannelMode as fidl::encoding::ValueTypeMarker>::borrow),
3163 encoder,
3164 offset + cur_offset,
3165 depth,
3166 )?;
3167
3168 _prev_end_offset = cur_offset + envelope_size;
3169 if 7 > max_ordinal {
3170 return Ok(());
3171 }
3172
3173 let cur_offset: usize = (7 - 1) * envelope_size;
3176
3177 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3179
3180 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3185 self.encoded_bit_rate
3186 .as_ref()
3187 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3188 encoder,
3189 offset + cur_offset,
3190 depth,
3191 )?;
3192
3193 _prev_end_offset = cur_offset + envelope_size;
3194 if 8 > max_ordinal {
3195 return Ok(());
3196 }
3197
3198 let cur_offset: usize = (8 - 1) * envelope_size;
3201
3202 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3204
3205 fidl::encoding::encode_in_envelope_optional::<AudioEncoderSettings, D>(
3210 self.encoder_settings
3211 .as_ref()
3212 .map(<AudioEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow),
3213 encoder,
3214 offset + cur_offset,
3215 depth,
3216 )?;
3217
3218 _prev_end_offset = cur_offset + envelope_size;
3219
3220 Ok(())
3221 }
3222 }
3223
3224 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3225 for AudioOffloadConfiguration
3226 {
3227 #[inline(always)]
3228 fn new_empty() -> Self {
3229 Self::default()
3230 }
3231
3232 unsafe fn decode(
3233 &mut self,
3234 decoder: &mut fidl::encoding::Decoder<'_, D>,
3235 offset: usize,
3236 mut depth: fidl::encoding::Depth,
3237 ) -> fidl::Result<()> {
3238 decoder.debug_check_bounds::<Self>(offset);
3239 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3240 None => return Err(fidl::Error::NotNullable),
3241 Some(len) => len,
3242 };
3243 if len == 0 {
3245 return Ok(());
3246 };
3247 depth.increment()?;
3248 let envelope_size = 8;
3249 let bytes_len = len * envelope_size;
3250 let offset = decoder.out_of_line_offset(bytes_len)?;
3251 let mut _next_ordinal_to_read = 0;
3253 let mut next_offset = offset;
3254 let end_offset = offset + bytes_len;
3255 _next_ordinal_to_read += 1;
3256 if next_offset >= end_offset {
3257 return Ok(());
3258 }
3259
3260 while _next_ordinal_to_read < 1 {
3262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3263 _next_ordinal_to_read += 1;
3264 next_offset += envelope_size;
3265 }
3266
3267 let next_out_of_line = decoder.next_out_of_line();
3268 let handles_before = decoder.remaining_handles();
3269 if let Some((inlined, num_bytes, num_handles)) =
3270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3271 {
3272 let member_inline_size =
3273 <AudioOffloadFeatures as fidl::encoding::TypeMarker>::inline_size(
3274 decoder.context,
3275 );
3276 if inlined != (member_inline_size <= 4) {
3277 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3278 }
3279 let inner_offset;
3280 let mut inner_depth = depth.clone();
3281 if inlined {
3282 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3283 inner_offset = next_offset;
3284 } else {
3285 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3286 inner_depth.increment()?;
3287 }
3288 let val_ref =
3289 self.codec.get_or_insert_with(|| fidl::new_empty!(AudioOffloadFeatures, D));
3290 fidl::decode!(
3291 AudioOffloadFeatures,
3292 D,
3293 val_ref,
3294 decoder,
3295 inner_offset,
3296 inner_depth
3297 )?;
3298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3299 {
3300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3301 }
3302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3304 }
3305 }
3306
3307 next_offset += envelope_size;
3308 _next_ordinal_to_read += 1;
3309 if next_offset >= end_offset {
3310 return Ok(());
3311 }
3312
3313 while _next_ordinal_to_read < 2 {
3315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3316 _next_ordinal_to_read += 1;
3317 next_offset += envelope_size;
3318 }
3319
3320 let next_out_of_line = decoder.next_out_of_line();
3321 let handles_before = decoder.remaining_handles();
3322 if let Some((inlined, num_bytes, num_handles)) =
3323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3324 {
3325 let member_inline_size =
3326 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3327 if inlined != (member_inline_size <= 4) {
3328 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3329 }
3330 let inner_offset;
3331 let mut inner_depth = depth.clone();
3332 if inlined {
3333 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3334 inner_offset = next_offset;
3335 } else {
3336 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3337 inner_depth.increment()?;
3338 }
3339 let val_ref = self.max_latency.get_or_insert_with(|| fidl::new_empty!(u16, D));
3340 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3341 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3342 {
3343 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3344 }
3345 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3346 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3347 }
3348 }
3349
3350 next_offset += envelope_size;
3351 _next_ordinal_to_read += 1;
3352 if next_offset >= end_offset {
3353 return Ok(());
3354 }
3355
3356 while _next_ordinal_to_read < 3 {
3358 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3359 _next_ordinal_to_read += 1;
3360 next_offset += envelope_size;
3361 }
3362
3363 let next_out_of_line = decoder.next_out_of_line();
3364 let handles_before = decoder.remaining_handles();
3365 if let Some((inlined, num_bytes, num_handles)) =
3366 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3367 {
3368 let member_inline_size =
3369 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3370 if inlined != (member_inline_size <= 4) {
3371 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3372 }
3373 let inner_offset;
3374 let mut inner_depth = depth.clone();
3375 if inlined {
3376 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3377 inner_offset = next_offset;
3378 } else {
3379 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3380 inner_depth.increment()?;
3381 }
3382 let val_ref = self.scms_t_enable.get_or_insert_with(|| fidl::new_empty!(bool, D));
3383 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3384 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3385 {
3386 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3387 }
3388 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3389 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3390 }
3391 }
3392
3393 next_offset += envelope_size;
3394 _next_ordinal_to_read += 1;
3395 if next_offset >= end_offset {
3396 return Ok(());
3397 }
3398
3399 while _next_ordinal_to_read < 4 {
3401 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3402 _next_ordinal_to_read += 1;
3403 next_offset += envelope_size;
3404 }
3405
3406 let next_out_of_line = decoder.next_out_of_line();
3407 let handles_before = decoder.remaining_handles();
3408 if let Some((inlined, num_bytes, num_handles)) =
3409 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3410 {
3411 let member_inline_size =
3412 <AudioSamplingFrequency as fidl::encoding::TypeMarker>::inline_size(
3413 decoder.context,
3414 );
3415 if inlined != (member_inline_size <= 4) {
3416 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3417 }
3418 let inner_offset;
3419 let mut inner_depth = depth.clone();
3420 if inlined {
3421 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3422 inner_offset = next_offset;
3423 } else {
3424 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3425 inner_depth.increment()?;
3426 }
3427 let val_ref = self
3428 .sampling_frequency
3429 .get_or_insert_with(|| fidl::new_empty!(AudioSamplingFrequency, D));
3430 fidl::decode!(
3431 AudioSamplingFrequency,
3432 D,
3433 val_ref,
3434 decoder,
3435 inner_offset,
3436 inner_depth
3437 )?;
3438 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3439 {
3440 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3441 }
3442 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3443 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3444 }
3445 }
3446
3447 next_offset += envelope_size;
3448 _next_ordinal_to_read += 1;
3449 if next_offset >= end_offset {
3450 return Ok(());
3451 }
3452
3453 while _next_ordinal_to_read < 5 {
3455 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3456 _next_ordinal_to_read += 1;
3457 next_offset += envelope_size;
3458 }
3459
3460 let next_out_of_line = decoder.next_out_of_line();
3461 let handles_before = decoder.remaining_handles();
3462 if let Some((inlined, num_bytes, num_handles)) =
3463 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3464 {
3465 let member_inline_size =
3466 <AudioBitsPerSample as fidl::encoding::TypeMarker>::inline_size(
3467 decoder.context,
3468 );
3469 if inlined != (member_inline_size <= 4) {
3470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3471 }
3472 let inner_offset;
3473 let mut inner_depth = depth.clone();
3474 if inlined {
3475 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3476 inner_offset = next_offset;
3477 } else {
3478 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3479 inner_depth.increment()?;
3480 }
3481 let val_ref = self
3482 .bits_per_sample
3483 .get_or_insert_with(|| fidl::new_empty!(AudioBitsPerSample, D));
3484 fidl::decode!(AudioBitsPerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
3485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3486 {
3487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3488 }
3489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3491 }
3492 }
3493
3494 next_offset += envelope_size;
3495 _next_ordinal_to_read += 1;
3496 if next_offset >= end_offset {
3497 return Ok(());
3498 }
3499
3500 while _next_ordinal_to_read < 6 {
3502 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3503 _next_ordinal_to_read += 1;
3504 next_offset += envelope_size;
3505 }
3506
3507 let next_out_of_line = decoder.next_out_of_line();
3508 let handles_before = decoder.remaining_handles();
3509 if let Some((inlined, num_bytes, num_handles)) =
3510 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3511 {
3512 let member_inline_size =
3513 <AudioChannelMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3514 if inlined != (member_inline_size <= 4) {
3515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3516 }
3517 let inner_offset;
3518 let mut inner_depth = depth.clone();
3519 if inlined {
3520 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3521 inner_offset = next_offset;
3522 } else {
3523 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3524 inner_depth.increment()?;
3525 }
3526 let val_ref =
3527 self.channel_mode.get_or_insert_with(|| fidl::new_empty!(AudioChannelMode, D));
3528 fidl::decode!(AudioChannelMode, D, val_ref, decoder, inner_offset, inner_depth)?;
3529 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3530 {
3531 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3532 }
3533 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3534 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3535 }
3536 }
3537
3538 next_offset += envelope_size;
3539 _next_ordinal_to_read += 1;
3540 if next_offset >= end_offset {
3541 return Ok(());
3542 }
3543
3544 while _next_ordinal_to_read < 7 {
3546 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3547 _next_ordinal_to_read += 1;
3548 next_offset += envelope_size;
3549 }
3550
3551 let next_out_of_line = decoder.next_out_of_line();
3552 let handles_before = decoder.remaining_handles();
3553 if let Some((inlined, num_bytes, num_handles)) =
3554 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3555 {
3556 let member_inline_size =
3557 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3558 if inlined != (member_inline_size <= 4) {
3559 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3560 }
3561 let inner_offset;
3562 let mut inner_depth = depth.clone();
3563 if inlined {
3564 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3565 inner_offset = next_offset;
3566 } else {
3567 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3568 inner_depth.increment()?;
3569 }
3570 let val_ref = self.encoded_bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
3571 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3572 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3573 {
3574 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3575 }
3576 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3577 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3578 }
3579 }
3580
3581 next_offset += envelope_size;
3582 _next_ordinal_to_read += 1;
3583 if next_offset >= end_offset {
3584 return Ok(());
3585 }
3586
3587 while _next_ordinal_to_read < 8 {
3589 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3590 _next_ordinal_to_read += 1;
3591 next_offset += envelope_size;
3592 }
3593
3594 let next_out_of_line = decoder.next_out_of_line();
3595 let handles_before = decoder.remaining_handles();
3596 if let Some((inlined, num_bytes, num_handles)) =
3597 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3598 {
3599 let member_inline_size =
3600 <AudioEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
3601 decoder.context,
3602 );
3603 if inlined != (member_inline_size <= 4) {
3604 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3605 }
3606 let inner_offset;
3607 let mut inner_depth = depth.clone();
3608 if inlined {
3609 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3610 inner_offset = next_offset;
3611 } else {
3612 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3613 inner_depth.increment()?;
3614 }
3615 let val_ref = self
3616 .encoder_settings
3617 .get_or_insert_with(|| fidl::new_empty!(AudioEncoderSettings, D));
3618 fidl::decode!(
3619 AudioEncoderSettings,
3620 D,
3621 val_ref,
3622 decoder,
3623 inner_offset,
3624 inner_depth
3625 )?;
3626 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3627 {
3628 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3629 }
3630 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3631 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3632 }
3633 }
3634
3635 next_offset += envelope_size;
3636
3637 while next_offset < end_offset {
3639 _next_ordinal_to_read += 1;
3640 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3641 next_offset += envelope_size;
3642 }
3643
3644 Ok(())
3645 }
3646 }
3647
3648 impl AudioOffloadExtGetSupportedFeaturesResponse {
3649 #[inline(always)]
3650 fn max_ordinal_present(&self) -> u64 {
3651 if let Some(_) = self.audio_offload_features {
3652 return 1;
3653 }
3654 0
3655 }
3656 }
3657
3658 impl fidl::encoding::ValueTypeMarker for AudioOffloadExtGetSupportedFeaturesResponse {
3659 type Borrowed<'a> = &'a Self;
3660 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3661 value
3662 }
3663 }
3664
3665 unsafe impl fidl::encoding::TypeMarker for AudioOffloadExtGetSupportedFeaturesResponse {
3666 type Owned = Self;
3667
3668 #[inline(always)]
3669 fn inline_align(_context: fidl::encoding::Context) -> usize {
3670 8
3671 }
3672
3673 #[inline(always)]
3674 fn inline_size(_context: fidl::encoding::Context) -> usize {
3675 16
3676 }
3677 }
3678
3679 unsafe impl<D: fidl::encoding::ResourceDialect>
3680 fidl::encoding::Encode<AudioOffloadExtGetSupportedFeaturesResponse, D>
3681 for &AudioOffloadExtGetSupportedFeaturesResponse
3682 {
3683 unsafe fn encode(
3684 self,
3685 encoder: &mut fidl::encoding::Encoder<'_, D>,
3686 offset: usize,
3687 mut depth: fidl::encoding::Depth,
3688 ) -> fidl::Result<()> {
3689 encoder.debug_check_bounds::<AudioOffloadExtGetSupportedFeaturesResponse>(offset);
3690 let max_ordinal: u64 = self.max_ordinal_present();
3692 encoder.write_num(max_ordinal, offset);
3693 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3694 if max_ordinal == 0 {
3696 return Ok(());
3697 }
3698 depth.increment()?;
3699 let envelope_size = 8;
3700 let bytes_len = max_ordinal as usize * envelope_size;
3701 #[allow(unused_variables)]
3702 let offset = encoder.out_of_line_offset(bytes_len);
3703 let mut _prev_end_offset: usize = 0;
3704 if 1 > max_ordinal {
3705 return Ok(());
3706 }
3707
3708 let cur_offset: usize = (1 - 1) * envelope_size;
3711
3712 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3714
3715 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AudioOffloadFeatures>, D>(
3720 self.audio_offload_features.as_ref().map(<fidl::encoding::UnboundedVector<AudioOffloadFeatures> as fidl::encoding::ValueTypeMarker>::borrow),
3721 encoder, offset + cur_offset, depth
3722 )?;
3723
3724 _prev_end_offset = cur_offset + envelope_size;
3725
3726 Ok(())
3727 }
3728 }
3729
3730 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3731 for AudioOffloadExtGetSupportedFeaturesResponse
3732 {
3733 #[inline(always)]
3734 fn new_empty() -> Self {
3735 Self::default()
3736 }
3737
3738 unsafe fn decode(
3739 &mut self,
3740 decoder: &mut fidl::encoding::Decoder<'_, D>,
3741 offset: usize,
3742 mut depth: fidl::encoding::Depth,
3743 ) -> fidl::Result<()> {
3744 decoder.debug_check_bounds::<Self>(offset);
3745 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3746 None => return Err(fidl::Error::NotNullable),
3747 Some(len) => len,
3748 };
3749 if len == 0 {
3751 return Ok(());
3752 };
3753 depth.increment()?;
3754 let envelope_size = 8;
3755 let bytes_len = len * envelope_size;
3756 let offset = decoder.out_of_line_offset(bytes_len)?;
3757 let mut _next_ordinal_to_read = 0;
3759 let mut next_offset = offset;
3760 let end_offset = offset + bytes_len;
3761 _next_ordinal_to_read += 1;
3762 if next_offset >= end_offset {
3763 return Ok(());
3764 }
3765
3766 while _next_ordinal_to_read < 1 {
3768 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3769 _next_ordinal_to_read += 1;
3770 next_offset += envelope_size;
3771 }
3772
3773 let next_out_of_line = decoder.next_out_of_line();
3774 let handles_before = decoder.remaining_handles();
3775 if let Some((inlined, num_bytes, num_handles)) =
3776 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3777 {
3778 let member_inline_size = <fidl::encoding::UnboundedVector<AudioOffloadFeatures> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3779 if inlined != (member_inline_size <= 4) {
3780 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3781 }
3782 let inner_offset;
3783 let mut inner_depth = depth.clone();
3784 if inlined {
3785 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3786 inner_offset = next_offset;
3787 } else {
3788 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3789 inner_depth.increment()?;
3790 }
3791 let val_ref = self.audio_offload_features.get_or_insert_with(|| {
3792 fidl::new_empty!(fidl::encoding::UnboundedVector<AudioOffloadFeatures>, D)
3793 });
3794 fidl::decode!(
3795 fidl::encoding::UnboundedVector<AudioOffloadFeatures>,
3796 D,
3797 val_ref,
3798 decoder,
3799 inner_offset,
3800 inner_depth
3801 )?;
3802 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3803 {
3804 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3805 }
3806 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3807 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3808 }
3809 }
3810
3811 next_offset += envelope_size;
3812
3813 while next_offset < end_offset {
3815 _next_ordinal_to_read += 1;
3816 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3817 next_offset += envelope_size;
3818 }
3819
3820 Ok(())
3821 }
3822 }
3823
3824 impl AudioSbcSupport {
3825 #[inline(always)]
3826 fn max_ordinal_present(&self) -> u64 {
3827 0
3828 }
3829 }
3830
3831 impl fidl::encoding::ValueTypeMarker for AudioSbcSupport {
3832 type Borrowed<'a> = &'a Self;
3833 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3834 value
3835 }
3836 }
3837
3838 unsafe impl fidl::encoding::TypeMarker for AudioSbcSupport {
3839 type Owned = Self;
3840
3841 #[inline(always)]
3842 fn inline_align(_context: fidl::encoding::Context) -> usize {
3843 8
3844 }
3845
3846 #[inline(always)]
3847 fn inline_size(_context: fidl::encoding::Context) -> usize {
3848 16
3849 }
3850 }
3851
3852 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioSbcSupport, D>
3853 for &AudioSbcSupport
3854 {
3855 unsafe fn encode(
3856 self,
3857 encoder: &mut fidl::encoding::Encoder<'_, D>,
3858 offset: usize,
3859 mut depth: fidl::encoding::Depth,
3860 ) -> fidl::Result<()> {
3861 encoder.debug_check_bounds::<AudioSbcSupport>(offset);
3862 let max_ordinal: u64 = self.max_ordinal_present();
3864 encoder.write_num(max_ordinal, offset);
3865 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3866 if max_ordinal == 0 {
3868 return Ok(());
3869 }
3870 depth.increment()?;
3871 let envelope_size = 8;
3872 let bytes_len = max_ordinal as usize * envelope_size;
3873 #[allow(unused_variables)]
3874 let offset = encoder.out_of_line_offset(bytes_len);
3875 let mut _prev_end_offset: usize = 0;
3876
3877 Ok(())
3878 }
3879 }
3880
3881 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioSbcSupport {
3882 #[inline(always)]
3883 fn new_empty() -> Self {
3884 Self::default()
3885 }
3886
3887 unsafe fn decode(
3888 &mut self,
3889 decoder: &mut fidl::encoding::Decoder<'_, D>,
3890 offset: usize,
3891 mut depth: fidl::encoding::Depth,
3892 ) -> fidl::Result<()> {
3893 decoder.debug_check_bounds::<Self>(offset);
3894 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3895 None => return Err(fidl::Error::NotNullable),
3896 Some(len) => len,
3897 };
3898 if len == 0 {
3900 return Ok(());
3901 };
3902 depth.increment()?;
3903 let envelope_size = 8;
3904 let bytes_len = len * envelope_size;
3905 let offset = decoder.out_of_line_offset(bytes_len)?;
3906 let mut _next_ordinal_to_read = 0;
3908 let mut next_offset = offset;
3909 let end_offset = offset + bytes_len;
3910
3911 while next_offset < end_offset {
3913 _next_ordinal_to_read += 1;
3914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3915 next_offset += envelope_size;
3916 }
3917
3918 Ok(())
3919 }
3920 }
3921
3922 impl Information {
3923 #[inline(always)]
3924 fn max_ordinal_present(&self) -> u64 {
3925 if let Some(_) = self.provider {
3926 return 4;
3927 }
3928 if let Some(_) = self.description {
3929 return 3;
3930 }
3931 if let Some(_) = self.name {
3932 return 2;
3933 }
3934 if let Some(_) = self.language {
3935 return 1;
3936 }
3937 0
3938 }
3939 }
3940
3941 impl fidl::encoding::ValueTypeMarker for Information {
3942 type Borrowed<'a> = &'a Self;
3943 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3944 value
3945 }
3946 }
3947
3948 unsafe impl fidl::encoding::TypeMarker for Information {
3949 type Owned = Self;
3950
3951 #[inline(always)]
3952 fn inline_align(_context: fidl::encoding::Context) -> usize {
3953 8
3954 }
3955
3956 #[inline(always)]
3957 fn inline_size(_context: fidl::encoding::Context) -> usize {
3958 16
3959 }
3960 }
3961
3962 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Information, D>
3963 for &Information
3964 {
3965 unsafe fn encode(
3966 self,
3967 encoder: &mut fidl::encoding::Encoder<'_, D>,
3968 offset: usize,
3969 mut depth: fidl::encoding::Depth,
3970 ) -> fidl::Result<()> {
3971 encoder.debug_check_bounds::<Information>(offset);
3972 let max_ordinal: u64 = self.max_ordinal_present();
3974 encoder.write_num(max_ordinal, offset);
3975 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3976 if max_ordinal == 0 {
3978 return Ok(());
3979 }
3980 depth.increment()?;
3981 let envelope_size = 8;
3982 let bytes_len = max_ordinal as usize * envelope_size;
3983 #[allow(unused_variables)]
3984 let offset = encoder.out_of_line_offset(bytes_len);
3985 let mut _prev_end_offset: usize = 0;
3986 if 1 > max_ordinal {
3987 return Ok(());
3988 }
3989
3990 let cur_offset: usize = (1 - 1) * envelope_size;
3993
3994 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3996
3997 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2>, D>(
4002 self.language.as_ref().map(
4003 <fidl::encoding::BoundedString<2> as fidl::encoding::ValueTypeMarker>::borrow,
4004 ),
4005 encoder,
4006 offset + cur_offset,
4007 depth,
4008 )?;
4009
4010 _prev_end_offset = cur_offset + envelope_size;
4011 if 2 > max_ordinal {
4012 return Ok(());
4013 }
4014
4015 let cur_offset: usize = (2 - 1) * envelope_size;
4018
4019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4021
4022 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4027 self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4028 encoder, offset + cur_offset, depth
4029 )?;
4030
4031 _prev_end_offset = cur_offset + envelope_size;
4032 if 3 > max_ordinal {
4033 return Ok(());
4034 }
4035
4036 let cur_offset: usize = (3 - 1) * envelope_size;
4039
4040 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4042
4043 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4048 self.description.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4049 encoder, offset + cur_offset, depth
4050 )?;
4051
4052 _prev_end_offset = cur_offset + envelope_size;
4053 if 4 > max_ordinal {
4054 return Ok(());
4055 }
4056
4057 let cur_offset: usize = (4 - 1) * envelope_size;
4060
4061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4063
4064 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4069 self.provider.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4070 encoder, offset + cur_offset, depth
4071 )?;
4072
4073 _prev_end_offset = cur_offset + envelope_size;
4074
4075 Ok(())
4076 }
4077 }
4078
4079 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Information {
4080 #[inline(always)]
4081 fn new_empty() -> Self {
4082 Self::default()
4083 }
4084
4085 unsafe fn decode(
4086 &mut self,
4087 decoder: &mut fidl::encoding::Decoder<'_, D>,
4088 offset: usize,
4089 mut depth: fidl::encoding::Depth,
4090 ) -> fidl::Result<()> {
4091 decoder.debug_check_bounds::<Self>(offset);
4092 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4093 None => return Err(fidl::Error::NotNullable),
4094 Some(len) => len,
4095 };
4096 if len == 0 {
4098 return Ok(());
4099 };
4100 depth.increment()?;
4101 let envelope_size = 8;
4102 let bytes_len = len * envelope_size;
4103 let offset = decoder.out_of_line_offset(bytes_len)?;
4104 let mut _next_ordinal_to_read = 0;
4106 let mut next_offset = offset;
4107 let end_offset = offset + bytes_len;
4108 _next_ordinal_to_read += 1;
4109 if next_offset >= end_offset {
4110 return Ok(());
4111 }
4112
4113 while _next_ordinal_to_read < 1 {
4115 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4116 _next_ordinal_to_read += 1;
4117 next_offset += envelope_size;
4118 }
4119
4120 let next_out_of_line = decoder.next_out_of_line();
4121 let handles_before = decoder.remaining_handles();
4122 if let Some((inlined, num_bytes, num_handles)) =
4123 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4124 {
4125 let member_inline_size =
4126 <fidl::encoding::BoundedString<2> as fidl::encoding::TypeMarker>::inline_size(
4127 decoder.context,
4128 );
4129 if inlined != (member_inline_size <= 4) {
4130 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4131 }
4132 let inner_offset;
4133 let mut inner_depth = depth.clone();
4134 if inlined {
4135 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4136 inner_offset = next_offset;
4137 } else {
4138 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4139 inner_depth.increment()?;
4140 }
4141 let val_ref = self
4142 .language
4143 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<2>, D));
4144 fidl::decode!(
4145 fidl::encoding::BoundedString<2>,
4146 D,
4147 val_ref,
4148 decoder,
4149 inner_offset,
4150 inner_depth
4151 )?;
4152 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4153 {
4154 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4155 }
4156 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4157 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4158 }
4159 }
4160
4161 next_offset += envelope_size;
4162 _next_ordinal_to_read += 1;
4163 if next_offset >= end_offset {
4164 return Ok(());
4165 }
4166
4167 while _next_ordinal_to_read < 2 {
4169 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4170 _next_ordinal_to_read += 1;
4171 next_offset += envelope_size;
4172 }
4173
4174 let next_out_of_line = decoder.next_out_of_line();
4175 let handles_before = decoder.remaining_handles();
4176 if let Some((inlined, num_bytes, num_handles)) =
4177 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4178 {
4179 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4180 if inlined != (member_inline_size <= 4) {
4181 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4182 }
4183 let inner_offset;
4184 let mut inner_depth = depth.clone();
4185 if inlined {
4186 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4187 inner_offset = next_offset;
4188 } else {
4189 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4190 inner_depth.increment()?;
4191 }
4192 let val_ref = self.name.get_or_insert_with(|| {
4193 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4194 });
4195 fidl::decode!(
4196 fidl::encoding::BoundedString<1024>,
4197 D,
4198 val_ref,
4199 decoder,
4200 inner_offset,
4201 inner_depth
4202 )?;
4203 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4204 {
4205 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4206 }
4207 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4208 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4209 }
4210 }
4211
4212 next_offset += envelope_size;
4213 _next_ordinal_to_read += 1;
4214 if next_offset >= end_offset {
4215 return Ok(());
4216 }
4217
4218 while _next_ordinal_to_read < 3 {
4220 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4221 _next_ordinal_to_read += 1;
4222 next_offset += envelope_size;
4223 }
4224
4225 let next_out_of_line = decoder.next_out_of_line();
4226 let handles_before = decoder.remaining_handles();
4227 if let Some((inlined, num_bytes, num_handles)) =
4228 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4229 {
4230 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4231 if inlined != (member_inline_size <= 4) {
4232 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4233 }
4234 let inner_offset;
4235 let mut inner_depth = depth.clone();
4236 if inlined {
4237 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4238 inner_offset = next_offset;
4239 } else {
4240 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4241 inner_depth.increment()?;
4242 }
4243 let val_ref = self.description.get_or_insert_with(|| {
4244 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4245 });
4246 fidl::decode!(
4247 fidl::encoding::BoundedString<1024>,
4248 D,
4249 val_ref,
4250 decoder,
4251 inner_offset,
4252 inner_depth
4253 )?;
4254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4255 {
4256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4257 }
4258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4260 }
4261 }
4262
4263 next_offset += envelope_size;
4264 _next_ordinal_to_read += 1;
4265 if next_offset >= end_offset {
4266 return Ok(());
4267 }
4268
4269 while _next_ordinal_to_read < 4 {
4271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4272 _next_ordinal_to_read += 1;
4273 next_offset += envelope_size;
4274 }
4275
4276 let next_out_of_line = decoder.next_out_of_line();
4277 let handles_before = decoder.remaining_handles();
4278 if let Some((inlined, num_bytes, num_handles)) =
4279 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4280 {
4281 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4282 if inlined != (member_inline_size <= 4) {
4283 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4284 }
4285 let inner_offset;
4286 let mut inner_depth = depth.clone();
4287 if inlined {
4288 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4289 inner_offset = next_offset;
4290 } else {
4291 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4292 inner_depth.increment()?;
4293 }
4294 let val_ref = self.provider.get_or_insert_with(|| {
4295 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4296 });
4297 fidl::decode!(
4298 fidl::encoding::BoundedString<1024>,
4299 D,
4300 val_ref,
4301 decoder,
4302 inner_offset,
4303 inner_depth
4304 )?;
4305 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4306 {
4307 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4308 }
4309 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4310 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4311 }
4312 }
4313
4314 next_offset += envelope_size;
4315
4316 while next_offset < end_offset {
4318 _next_ordinal_to_read += 1;
4319 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4320 next_offset += envelope_size;
4321 }
4322
4323 Ok(())
4324 }
4325 }
4326
4327 impl L2capParameters {
4328 #[inline(always)]
4329 fn max_ordinal_present(&self) -> u64 {
4330 if let Some(_) = self.parameters {
4331 return 2;
4332 }
4333 if let Some(_) = self.psm {
4334 return 1;
4335 }
4336 0
4337 }
4338 }
4339
4340 impl fidl::encoding::ValueTypeMarker for L2capParameters {
4341 type Borrowed<'a> = &'a Self;
4342 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4343 value
4344 }
4345 }
4346
4347 unsafe impl fidl::encoding::TypeMarker for L2capParameters {
4348 type Owned = Self;
4349
4350 #[inline(always)]
4351 fn inline_align(_context: fidl::encoding::Context) -> usize {
4352 8
4353 }
4354
4355 #[inline(always)]
4356 fn inline_size(_context: fidl::encoding::Context) -> usize {
4357 16
4358 }
4359 }
4360
4361 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<L2capParameters, D>
4362 for &L2capParameters
4363 {
4364 unsafe fn encode(
4365 self,
4366 encoder: &mut fidl::encoding::Encoder<'_, D>,
4367 offset: usize,
4368 mut depth: fidl::encoding::Depth,
4369 ) -> fidl::Result<()> {
4370 encoder.debug_check_bounds::<L2capParameters>(offset);
4371 let max_ordinal: u64 = self.max_ordinal_present();
4373 encoder.write_num(max_ordinal, offset);
4374 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4375 if max_ordinal == 0 {
4377 return Ok(());
4378 }
4379 depth.increment()?;
4380 let envelope_size = 8;
4381 let bytes_len = max_ordinal as usize * envelope_size;
4382 #[allow(unused_variables)]
4383 let offset = encoder.out_of_line_offset(bytes_len);
4384 let mut _prev_end_offset: usize = 0;
4385 if 1 > max_ordinal {
4386 return Ok(());
4387 }
4388
4389 let cur_offset: usize = (1 - 1) * envelope_size;
4392
4393 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4395
4396 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4401 self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4402 encoder,
4403 offset + cur_offset,
4404 depth,
4405 )?;
4406
4407 _prev_end_offset = cur_offset + envelope_size;
4408 if 2 > max_ordinal {
4409 return Ok(());
4410 }
4411
4412 let cur_offset: usize = (2 - 1) * envelope_size;
4415
4416 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4418
4419 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::ChannelParameters, D>(
4424 self.parameters.as_ref().map(<fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow),
4425 encoder, offset + cur_offset, depth
4426 )?;
4427
4428 _prev_end_offset = cur_offset + envelope_size;
4429
4430 Ok(())
4431 }
4432 }
4433
4434 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for L2capParameters {
4435 #[inline(always)]
4436 fn new_empty() -> Self {
4437 Self::default()
4438 }
4439
4440 unsafe fn decode(
4441 &mut self,
4442 decoder: &mut fidl::encoding::Decoder<'_, D>,
4443 offset: usize,
4444 mut depth: fidl::encoding::Depth,
4445 ) -> fidl::Result<()> {
4446 decoder.debug_check_bounds::<Self>(offset);
4447 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4448 None => return Err(fidl::Error::NotNullable),
4449 Some(len) => len,
4450 };
4451 if len == 0 {
4453 return Ok(());
4454 };
4455 depth.increment()?;
4456 let envelope_size = 8;
4457 let bytes_len = len * envelope_size;
4458 let offset = decoder.out_of_line_offset(bytes_len)?;
4459 let mut _next_ordinal_to_read = 0;
4461 let mut next_offset = offset;
4462 let end_offset = offset + bytes_len;
4463 _next_ordinal_to_read += 1;
4464 if next_offset >= end_offset {
4465 return Ok(());
4466 }
4467
4468 while _next_ordinal_to_read < 1 {
4470 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4471 _next_ordinal_to_read += 1;
4472 next_offset += envelope_size;
4473 }
4474
4475 let next_out_of_line = decoder.next_out_of_line();
4476 let handles_before = decoder.remaining_handles();
4477 if let Some((inlined, num_bytes, num_handles)) =
4478 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4479 {
4480 let member_inline_size =
4481 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4482 if inlined != (member_inline_size <= 4) {
4483 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4484 }
4485 let inner_offset;
4486 let mut inner_depth = depth.clone();
4487 if inlined {
4488 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4489 inner_offset = next_offset;
4490 } else {
4491 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4492 inner_depth.increment()?;
4493 }
4494 let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
4495 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4496 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4497 {
4498 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4499 }
4500 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4501 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4502 }
4503 }
4504
4505 next_offset += envelope_size;
4506 _next_ordinal_to_read += 1;
4507 if next_offset >= end_offset {
4508 return Ok(());
4509 }
4510
4511 while _next_ordinal_to_read < 2 {
4513 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4514 _next_ordinal_to_read += 1;
4515 next_offset += envelope_size;
4516 }
4517
4518 let next_out_of_line = decoder.next_out_of_line();
4519 let handles_before = decoder.remaining_handles();
4520 if let Some((inlined, num_bytes, num_handles)) =
4521 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4522 {
4523 let member_inline_size = <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4524 if inlined != (member_inline_size <= 4) {
4525 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4526 }
4527 let inner_offset;
4528 let mut inner_depth = depth.clone();
4529 if inlined {
4530 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4531 inner_offset = next_offset;
4532 } else {
4533 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4534 inner_depth.increment()?;
4535 }
4536 let val_ref = self.parameters.get_or_insert_with(|| {
4537 fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D)
4538 });
4539 fidl::decode!(
4540 fidl_fuchsia_bluetooth__common::ChannelParameters,
4541 D,
4542 val_ref,
4543 decoder,
4544 inner_offset,
4545 inner_depth
4546 )?;
4547 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4548 {
4549 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4550 }
4551 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4552 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4553 }
4554 }
4555
4556 next_offset += envelope_size;
4557
4558 while next_offset < end_offset {
4560 _next_ordinal_to_read += 1;
4561 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4562 next_offset += envelope_size;
4563 }
4564
4565 Ok(())
4566 }
4567 }
4568
4569 impl ProfileDescriptor {
4570 #[inline(always)]
4571 fn max_ordinal_present(&self) -> u64 {
4572 if let Some(_) = self.minor_version {
4573 return 3;
4574 }
4575 if let Some(_) = self.major_version {
4576 return 2;
4577 }
4578 if let Some(_) = self.profile_id {
4579 return 1;
4580 }
4581 0
4582 }
4583 }
4584
4585 impl fidl::encoding::ValueTypeMarker for ProfileDescriptor {
4586 type Borrowed<'a> = &'a Self;
4587 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4588 value
4589 }
4590 }
4591
4592 unsafe impl fidl::encoding::TypeMarker for ProfileDescriptor {
4593 type Owned = Self;
4594
4595 #[inline(always)]
4596 fn inline_align(_context: fidl::encoding::Context) -> usize {
4597 8
4598 }
4599
4600 #[inline(always)]
4601 fn inline_size(_context: fidl::encoding::Context) -> usize {
4602 16
4603 }
4604 }
4605
4606 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProfileDescriptor, D>
4607 for &ProfileDescriptor
4608 {
4609 unsafe fn encode(
4610 self,
4611 encoder: &mut fidl::encoding::Encoder<'_, D>,
4612 offset: usize,
4613 mut depth: fidl::encoding::Depth,
4614 ) -> fidl::Result<()> {
4615 encoder.debug_check_bounds::<ProfileDescriptor>(offset);
4616 let max_ordinal: u64 = self.max_ordinal_present();
4618 encoder.write_num(max_ordinal, offset);
4619 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4620 if max_ordinal == 0 {
4622 return Ok(());
4623 }
4624 depth.increment()?;
4625 let envelope_size = 8;
4626 let bytes_len = max_ordinal as usize * envelope_size;
4627 #[allow(unused_variables)]
4628 let offset = encoder.out_of_line_offset(bytes_len);
4629 let mut _prev_end_offset: usize = 0;
4630 if 1 > max_ordinal {
4631 return Ok(());
4632 }
4633
4634 let cur_offset: usize = (1 - 1) * envelope_size;
4637
4638 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4640
4641 fidl::encoding::encode_in_envelope_optional::<ServiceClassProfileIdentifier, D>(
4646 self.profile_id.as_ref().map(
4647 <ServiceClassProfileIdentifier as fidl::encoding::ValueTypeMarker>::borrow,
4648 ),
4649 encoder,
4650 offset + cur_offset,
4651 depth,
4652 )?;
4653
4654 _prev_end_offset = cur_offset + envelope_size;
4655 if 2 > max_ordinal {
4656 return Ok(());
4657 }
4658
4659 let cur_offset: usize = (2 - 1) * envelope_size;
4662
4663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4665
4666 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4671 self.major_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4672 encoder,
4673 offset + cur_offset,
4674 depth,
4675 )?;
4676
4677 _prev_end_offset = cur_offset + envelope_size;
4678 if 3 > max_ordinal {
4679 return Ok(());
4680 }
4681
4682 let cur_offset: usize = (3 - 1) * envelope_size;
4685
4686 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4688
4689 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4694 self.minor_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4695 encoder,
4696 offset + cur_offset,
4697 depth,
4698 )?;
4699
4700 _prev_end_offset = cur_offset + envelope_size;
4701
4702 Ok(())
4703 }
4704 }
4705
4706 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProfileDescriptor {
4707 #[inline(always)]
4708 fn new_empty() -> Self {
4709 Self::default()
4710 }
4711
4712 unsafe fn decode(
4713 &mut self,
4714 decoder: &mut fidl::encoding::Decoder<'_, D>,
4715 offset: usize,
4716 mut depth: fidl::encoding::Depth,
4717 ) -> fidl::Result<()> {
4718 decoder.debug_check_bounds::<Self>(offset);
4719 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4720 None => return Err(fidl::Error::NotNullable),
4721 Some(len) => len,
4722 };
4723 if len == 0 {
4725 return Ok(());
4726 };
4727 depth.increment()?;
4728 let envelope_size = 8;
4729 let bytes_len = len * envelope_size;
4730 let offset = decoder.out_of_line_offset(bytes_len)?;
4731 let mut _next_ordinal_to_read = 0;
4733 let mut next_offset = offset;
4734 let end_offset = offset + bytes_len;
4735 _next_ordinal_to_read += 1;
4736 if next_offset >= end_offset {
4737 return Ok(());
4738 }
4739
4740 while _next_ordinal_to_read < 1 {
4742 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4743 _next_ordinal_to_read += 1;
4744 next_offset += envelope_size;
4745 }
4746
4747 let next_out_of_line = decoder.next_out_of_line();
4748 let handles_before = decoder.remaining_handles();
4749 if let Some((inlined, num_bytes, num_handles)) =
4750 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4751 {
4752 let member_inline_size =
4753 <ServiceClassProfileIdentifier as fidl::encoding::TypeMarker>::inline_size(
4754 decoder.context,
4755 );
4756 if inlined != (member_inline_size <= 4) {
4757 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4758 }
4759 let inner_offset;
4760 let mut inner_depth = depth.clone();
4761 if inlined {
4762 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4763 inner_offset = next_offset;
4764 } else {
4765 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4766 inner_depth.increment()?;
4767 }
4768 let val_ref = self
4769 .profile_id
4770 .get_or_insert_with(|| fidl::new_empty!(ServiceClassProfileIdentifier, D));
4771 fidl::decode!(
4772 ServiceClassProfileIdentifier,
4773 D,
4774 val_ref,
4775 decoder,
4776 inner_offset,
4777 inner_depth
4778 )?;
4779 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4780 {
4781 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4782 }
4783 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4784 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4785 }
4786 }
4787
4788 next_offset += envelope_size;
4789 _next_ordinal_to_read += 1;
4790 if next_offset >= end_offset {
4791 return Ok(());
4792 }
4793
4794 while _next_ordinal_to_read < 2 {
4796 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4797 _next_ordinal_to_read += 1;
4798 next_offset += envelope_size;
4799 }
4800
4801 let next_out_of_line = decoder.next_out_of_line();
4802 let handles_before = decoder.remaining_handles();
4803 if let Some((inlined, num_bytes, num_handles)) =
4804 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4805 {
4806 let member_inline_size =
4807 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4808 if inlined != (member_inline_size <= 4) {
4809 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4810 }
4811 let inner_offset;
4812 let mut inner_depth = depth.clone();
4813 if inlined {
4814 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4815 inner_offset = next_offset;
4816 } else {
4817 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4818 inner_depth.increment()?;
4819 }
4820 let val_ref = self.major_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4821 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4822 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4823 {
4824 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4825 }
4826 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4827 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4828 }
4829 }
4830
4831 next_offset += envelope_size;
4832 _next_ordinal_to_read += 1;
4833 if next_offset >= end_offset {
4834 return Ok(());
4835 }
4836
4837 while _next_ordinal_to_read < 3 {
4839 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4840 _next_ordinal_to_read += 1;
4841 next_offset += envelope_size;
4842 }
4843
4844 let next_out_of_line = decoder.next_out_of_line();
4845 let handles_before = decoder.remaining_handles();
4846 if let Some((inlined, num_bytes, num_handles)) =
4847 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4848 {
4849 let member_inline_size =
4850 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4851 if inlined != (member_inline_size <= 4) {
4852 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4853 }
4854 let inner_offset;
4855 let mut inner_depth = depth.clone();
4856 if inlined {
4857 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4858 inner_offset = next_offset;
4859 } else {
4860 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4861 inner_depth.increment()?;
4862 }
4863 let val_ref = self.minor_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4864 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4865 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4866 {
4867 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4868 }
4869 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4870 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4871 }
4872 }
4873
4874 next_offset += envelope_size;
4875
4876 while next_offset < end_offset {
4878 _next_ordinal_to_read += 1;
4879 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4880 next_offset += envelope_size;
4881 }
4882
4883 Ok(())
4884 }
4885 }
4886
4887 impl ProfileAdvertiseResponse {
4888 #[inline(always)]
4889 fn max_ordinal_present(&self) -> u64 {
4890 if let Some(_) = self.services {
4891 return 1;
4892 }
4893 0
4894 }
4895 }
4896
4897 impl fidl::encoding::ValueTypeMarker for ProfileAdvertiseResponse {
4898 type Borrowed<'a> = &'a Self;
4899 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4900 value
4901 }
4902 }
4903
4904 unsafe impl fidl::encoding::TypeMarker for ProfileAdvertiseResponse {
4905 type Owned = Self;
4906
4907 #[inline(always)]
4908 fn inline_align(_context: fidl::encoding::Context) -> usize {
4909 8
4910 }
4911
4912 #[inline(always)]
4913 fn inline_size(_context: fidl::encoding::Context) -> usize {
4914 16
4915 }
4916 }
4917
4918 unsafe impl<D: fidl::encoding::ResourceDialect>
4919 fidl::encoding::Encode<ProfileAdvertiseResponse, D> for &ProfileAdvertiseResponse
4920 {
4921 unsafe fn encode(
4922 self,
4923 encoder: &mut fidl::encoding::Encoder<'_, D>,
4924 offset: usize,
4925 mut depth: fidl::encoding::Depth,
4926 ) -> fidl::Result<()> {
4927 encoder.debug_check_bounds::<ProfileAdvertiseResponse>(offset);
4928 let max_ordinal: u64 = self.max_ordinal_present();
4930 encoder.write_num(max_ordinal, offset);
4931 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4932 if max_ordinal == 0 {
4934 return Ok(());
4935 }
4936 depth.increment()?;
4937 let envelope_size = 8;
4938 let bytes_len = max_ordinal as usize * envelope_size;
4939 #[allow(unused_variables)]
4940 let offset = encoder.out_of_line_offset(bytes_len);
4941 let mut _prev_end_offset: usize = 0;
4942 if 1 > max_ordinal {
4943 return Ok(());
4944 }
4945
4946 let cur_offset: usize = (1 - 1) * envelope_size;
4949
4950 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4952
4953 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ServiceDefinition, 32>, D>(
4958 self.services.as_ref().map(<fidl::encoding::Vector<ServiceDefinition, 32> as fidl::encoding::ValueTypeMarker>::borrow),
4959 encoder, offset + cur_offset, depth
4960 )?;
4961
4962 _prev_end_offset = cur_offset + envelope_size;
4963
4964 Ok(())
4965 }
4966 }
4967
4968 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4969 for ProfileAdvertiseResponse
4970 {
4971 #[inline(always)]
4972 fn new_empty() -> Self {
4973 Self::default()
4974 }
4975
4976 unsafe fn decode(
4977 &mut self,
4978 decoder: &mut fidl::encoding::Decoder<'_, D>,
4979 offset: usize,
4980 mut depth: fidl::encoding::Depth,
4981 ) -> fidl::Result<()> {
4982 decoder.debug_check_bounds::<Self>(offset);
4983 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4984 None => return Err(fidl::Error::NotNullable),
4985 Some(len) => len,
4986 };
4987 if len == 0 {
4989 return Ok(());
4990 };
4991 depth.increment()?;
4992 let envelope_size = 8;
4993 let bytes_len = len * envelope_size;
4994 let offset = decoder.out_of_line_offset(bytes_len)?;
4995 let mut _next_ordinal_to_read = 0;
4997 let mut next_offset = offset;
4998 let end_offset = offset + bytes_len;
4999 _next_ordinal_to_read += 1;
5000 if next_offset >= end_offset {
5001 return Ok(());
5002 }
5003
5004 while _next_ordinal_to_read < 1 {
5006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5007 _next_ordinal_to_read += 1;
5008 next_offset += envelope_size;
5009 }
5010
5011 let next_out_of_line = decoder.next_out_of_line();
5012 let handles_before = decoder.remaining_handles();
5013 if let Some((inlined, num_bytes, num_handles)) =
5014 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5015 {
5016 let member_inline_size = <fidl::encoding::Vector<ServiceDefinition, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5017 if inlined != (member_inline_size <= 4) {
5018 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5019 }
5020 let inner_offset;
5021 let mut inner_depth = depth.clone();
5022 if inlined {
5023 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5024 inner_offset = next_offset;
5025 } else {
5026 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5027 inner_depth.increment()?;
5028 }
5029 let val_ref = self.services.get_or_insert_with(
5030 || fidl::new_empty!(fidl::encoding::Vector<ServiceDefinition, 32>, D),
5031 );
5032 fidl::decode!(fidl::encoding::Vector<ServiceDefinition, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5033 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5034 {
5035 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5036 }
5037 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5038 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5039 }
5040 }
5041
5042 next_offset += envelope_size;
5043
5044 while next_offset < end_offset {
5046 _next_ordinal_to_read += 1;
5047 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5048 next_offset += envelope_size;
5049 }
5050
5051 Ok(())
5052 }
5053 }
5054
5055 impl ProtocolDescriptor {
5056 #[inline(always)]
5057 fn max_ordinal_present(&self) -> u64 {
5058 if let Some(_) = self.params {
5059 return 2;
5060 }
5061 if let Some(_) = self.protocol {
5062 return 1;
5063 }
5064 0
5065 }
5066 }
5067
5068 impl fidl::encoding::ValueTypeMarker for ProtocolDescriptor {
5069 type Borrowed<'a> = &'a Self;
5070 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5071 value
5072 }
5073 }
5074
5075 unsafe impl fidl::encoding::TypeMarker for ProtocolDescriptor {
5076 type Owned = Self;
5077
5078 #[inline(always)]
5079 fn inline_align(_context: fidl::encoding::Context) -> usize {
5080 8
5081 }
5082
5083 #[inline(always)]
5084 fn inline_size(_context: fidl::encoding::Context) -> usize {
5085 16
5086 }
5087 }
5088
5089 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProtocolDescriptor, D>
5090 for &ProtocolDescriptor
5091 {
5092 unsafe fn encode(
5093 self,
5094 encoder: &mut fidl::encoding::Encoder<'_, D>,
5095 offset: usize,
5096 mut depth: fidl::encoding::Depth,
5097 ) -> fidl::Result<()> {
5098 encoder.debug_check_bounds::<ProtocolDescriptor>(offset);
5099 let max_ordinal: u64 = self.max_ordinal_present();
5101 encoder.write_num(max_ordinal, offset);
5102 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5103 if max_ordinal == 0 {
5105 return Ok(());
5106 }
5107 depth.increment()?;
5108 let envelope_size = 8;
5109 let bytes_len = max_ordinal as usize * envelope_size;
5110 #[allow(unused_variables)]
5111 let offset = encoder.out_of_line_offset(bytes_len);
5112 let mut _prev_end_offset: usize = 0;
5113 if 1 > max_ordinal {
5114 return Ok(());
5115 }
5116
5117 let cur_offset: usize = (1 - 1) * envelope_size;
5120
5121 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5123
5124 fidl::encoding::encode_in_envelope_optional::<ProtocolIdentifier, D>(
5129 self.protocol
5130 .as_ref()
5131 .map(<ProtocolIdentifier as fidl::encoding::ValueTypeMarker>::borrow),
5132 encoder,
5133 offset + cur_offset,
5134 depth,
5135 )?;
5136
5137 _prev_end_offset = cur_offset + envelope_size;
5138 if 2 > max_ordinal {
5139 return Ok(());
5140 }
5141
5142 let cur_offset: usize = (2 - 1) * envelope_size;
5145
5146 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5148
5149 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DataElement, 255>, D>(
5154 self.params.as_ref().map(<fidl::encoding::Vector<DataElement, 255> as fidl::encoding::ValueTypeMarker>::borrow),
5155 encoder, offset + cur_offset, depth
5156 )?;
5157
5158 _prev_end_offset = cur_offset + envelope_size;
5159
5160 Ok(())
5161 }
5162 }
5163
5164 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolDescriptor {
5165 #[inline(always)]
5166 fn new_empty() -> Self {
5167 Self::default()
5168 }
5169
5170 unsafe fn decode(
5171 &mut self,
5172 decoder: &mut fidl::encoding::Decoder<'_, D>,
5173 offset: usize,
5174 mut depth: fidl::encoding::Depth,
5175 ) -> fidl::Result<()> {
5176 decoder.debug_check_bounds::<Self>(offset);
5177 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5178 None => return Err(fidl::Error::NotNullable),
5179 Some(len) => len,
5180 };
5181 if len == 0 {
5183 return Ok(());
5184 };
5185 depth.increment()?;
5186 let envelope_size = 8;
5187 let bytes_len = len * envelope_size;
5188 let offset = decoder.out_of_line_offset(bytes_len)?;
5189 let mut _next_ordinal_to_read = 0;
5191 let mut next_offset = offset;
5192 let end_offset = offset + bytes_len;
5193 _next_ordinal_to_read += 1;
5194 if next_offset >= end_offset {
5195 return Ok(());
5196 }
5197
5198 while _next_ordinal_to_read < 1 {
5200 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5201 _next_ordinal_to_read += 1;
5202 next_offset += envelope_size;
5203 }
5204
5205 let next_out_of_line = decoder.next_out_of_line();
5206 let handles_before = decoder.remaining_handles();
5207 if let Some((inlined, num_bytes, num_handles)) =
5208 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5209 {
5210 let member_inline_size =
5211 <ProtocolIdentifier as fidl::encoding::TypeMarker>::inline_size(
5212 decoder.context,
5213 );
5214 if inlined != (member_inline_size <= 4) {
5215 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5216 }
5217 let inner_offset;
5218 let mut inner_depth = depth.clone();
5219 if inlined {
5220 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5221 inner_offset = next_offset;
5222 } else {
5223 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5224 inner_depth.increment()?;
5225 }
5226 let val_ref =
5227 self.protocol.get_or_insert_with(|| fidl::new_empty!(ProtocolIdentifier, D));
5228 fidl::decode!(ProtocolIdentifier, D, val_ref, decoder, inner_offset, inner_depth)?;
5229 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5230 {
5231 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5232 }
5233 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5234 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5235 }
5236 }
5237
5238 next_offset += envelope_size;
5239 _next_ordinal_to_read += 1;
5240 if next_offset >= end_offset {
5241 return Ok(());
5242 }
5243
5244 while _next_ordinal_to_read < 2 {
5246 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5247 _next_ordinal_to_read += 1;
5248 next_offset += envelope_size;
5249 }
5250
5251 let next_out_of_line = decoder.next_out_of_line();
5252 let handles_before = decoder.remaining_handles();
5253 if let Some((inlined, num_bytes, num_handles)) =
5254 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5255 {
5256 let member_inline_size = <fidl::encoding::Vector<DataElement, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5257 if inlined != (member_inline_size <= 4) {
5258 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5259 }
5260 let inner_offset;
5261 let mut inner_depth = depth.clone();
5262 if inlined {
5263 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5264 inner_offset = next_offset;
5265 } else {
5266 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5267 inner_depth.increment()?;
5268 }
5269 let val_ref = self.params.get_or_insert_with(
5270 || fidl::new_empty!(fidl::encoding::Vector<DataElement, 255>, D),
5271 );
5272 fidl::decode!(fidl::encoding::Vector<DataElement, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
5273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5274 {
5275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5276 }
5277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5279 }
5280 }
5281
5282 next_offset += envelope_size;
5283
5284 while next_offset < end_offset {
5286 _next_ordinal_to_read += 1;
5287 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5288 next_offset += envelope_size;
5289 }
5290
5291 Ok(())
5292 }
5293 }
5294
5295 impl RfcommParameters {
5296 #[inline(always)]
5297 fn max_ordinal_present(&self) -> u64 {
5298 if let Some(_) = self.channel {
5299 return 1;
5300 }
5301 0
5302 }
5303 }
5304
5305 impl fidl::encoding::ValueTypeMarker for RfcommParameters {
5306 type Borrowed<'a> = &'a Self;
5307 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5308 value
5309 }
5310 }
5311
5312 unsafe impl fidl::encoding::TypeMarker for RfcommParameters {
5313 type Owned = Self;
5314
5315 #[inline(always)]
5316 fn inline_align(_context: fidl::encoding::Context) -> usize {
5317 8
5318 }
5319
5320 #[inline(always)]
5321 fn inline_size(_context: fidl::encoding::Context) -> usize {
5322 16
5323 }
5324 }
5325
5326 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RfcommParameters, D>
5327 for &RfcommParameters
5328 {
5329 unsafe fn encode(
5330 self,
5331 encoder: &mut fidl::encoding::Encoder<'_, D>,
5332 offset: usize,
5333 mut depth: fidl::encoding::Depth,
5334 ) -> fidl::Result<()> {
5335 encoder.debug_check_bounds::<RfcommParameters>(offset);
5336 let max_ordinal: u64 = self.max_ordinal_present();
5338 encoder.write_num(max_ordinal, offset);
5339 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5340 if max_ordinal == 0 {
5342 return Ok(());
5343 }
5344 depth.increment()?;
5345 let envelope_size = 8;
5346 let bytes_len = max_ordinal as usize * envelope_size;
5347 #[allow(unused_variables)]
5348 let offset = encoder.out_of_line_offset(bytes_len);
5349 let mut _prev_end_offset: usize = 0;
5350 if 1 > max_ordinal {
5351 return Ok(());
5352 }
5353
5354 let cur_offset: usize = (1 - 1) * envelope_size;
5357
5358 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5360
5361 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5366 self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5367 encoder,
5368 offset + cur_offset,
5369 depth,
5370 )?;
5371
5372 _prev_end_offset = cur_offset + envelope_size;
5373
5374 Ok(())
5375 }
5376 }
5377
5378 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RfcommParameters {
5379 #[inline(always)]
5380 fn new_empty() -> Self {
5381 Self::default()
5382 }
5383
5384 unsafe fn decode(
5385 &mut self,
5386 decoder: &mut fidl::encoding::Decoder<'_, D>,
5387 offset: usize,
5388 mut depth: fidl::encoding::Depth,
5389 ) -> fidl::Result<()> {
5390 decoder.debug_check_bounds::<Self>(offset);
5391 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5392 None => return Err(fidl::Error::NotNullable),
5393 Some(len) => len,
5394 };
5395 if len == 0 {
5397 return Ok(());
5398 };
5399 depth.increment()?;
5400 let envelope_size = 8;
5401 let bytes_len = len * envelope_size;
5402 let offset = decoder.out_of_line_offset(bytes_len)?;
5403 let mut _next_ordinal_to_read = 0;
5405 let mut next_offset = offset;
5406 let end_offset = offset + bytes_len;
5407 _next_ordinal_to_read += 1;
5408 if next_offset >= end_offset {
5409 return Ok(());
5410 }
5411
5412 while _next_ordinal_to_read < 1 {
5414 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5415 _next_ordinal_to_read += 1;
5416 next_offset += envelope_size;
5417 }
5418
5419 let next_out_of_line = decoder.next_out_of_line();
5420 let handles_before = decoder.remaining_handles();
5421 if let Some((inlined, num_bytes, num_handles)) =
5422 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5423 {
5424 let member_inline_size =
5425 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5426 if inlined != (member_inline_size <= 4) {
5427 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5428 }
5429 let inner_offset;
5430 let mut inner_depth = depth.clone();
5431 if inlined {
5432 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5433 inner_offset = next_offset;
5434 } else {
5435 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5436 inner_depth.increment()?;
5437 }
5438 let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
5439 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5441 {
5442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5443 }
5444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5446 }
5447 }
5448
5449 next_offset += envelope_size;
5450
5451 while next_offset < end_offset {
5453 _next_ordinal_to_read += 1;
5454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5455 next_offset += envelope_size;
5456 }
5457
5458 Ok(())
5459 }
5460 }
5461
5462 impl ScoConnectionParameters {
5463 #[inline(always)]
5464 fn max_ordinal_present(&self) -> u64 {
5465 if let Some(_) = self.max_tx_data_size {
5466 return 10;
5467 }
5468 if let Some(_) = self.path {
5469 return 9;
5470 }
5471 if let Some(_) = self.io_pcm_sample_payload_msb_position {
5472 return 8;
5473 }
5474 if let Some(_) = self.io_pcm_data_format {
5475 return 7;
5476 }
5477 if let Some(_) = self.io_frame_size {
5478 return 6;
5479 }
5480 if let Some(_) = self.io_coding_format {
5481 return 5;
5482 }
5483 if let Some(_) = self.io_bandwidth {
5484 return 4;
5485 }
5486 if let Some(_) = self.air_frame_size {
5487 return 3;
5488 }
5489 if let Some(_) = self.air_coding_format {
5490 return 2;
5491 }
5492 if let Some(_) = self.parameter_set {
5493 return 1;
5494 }
5495 0
5496 }
5497 }
5498
5499 impl fidl::encoding::ValueTypeMarker for ScoConnectionParameters {
5500 type Borrowed<'a> = &'a Self;
5501 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5502 value
5503 }
5504 }
5505
5506 unsafe impl fidl::encoding::TypeMarker for ScoConnectionParameters {
5507 type Owned = Self;
5508
5509 #[inline(always)]
5510 fn inline_align(_context: fidl::encoding::Context) -> usize {
5511 8
5512 }
5513
5514 #[inline(always)]
5515 fn inline_size(_context: fidl::encoding::Context) -> usize {
5516 16
5517 }
5518 }
5519
5520 unsafe impl<D: fidl::encoding::ResourceDialect>
5521 fidl::encoding::Encode<ScoConnectionParameters, D> for &ScoConnectionParameters
5522 {
5523 unsafe fn encode(
5524 self,
5525 encoder: &mut fidl::encoding::Encoder<'_, D>,
5526 offset: usize,
5527 mut depth: fidl::encoding::Depth,
5528 ) -> fidl::Result<()> {
5529 encoder.debug_check_bounds::<ScoConnectionParameters>(offset);
5530 let max_ordinal: u64 = self.max_ordinal_present();
5532 encoder.write_num(max_ordinal, offset);
5533 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5534 if max_ordinal == 0 {
5536 return Ok(());
5537 }
5538 depth.increment()?;
5539 let envelope_size = 8;
5540 let bytes_len = max_ordinal as usize * envelope_size;
5541 #[allow(unused_variables)]
5542 let offset = encoder.out_of_line_offset(bytes_len);
5543 let mut _prev_end_offset: usize = 0;
5544 if 1 > max_ordinal {
5545 return Ok(());
5546 }
5547
5548 let cur_offset: usize = (1 - 1) * envelope_size;
5551
5552 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5554
5555 fidl::encoding::encode_in_envelope_optional::<HfpParameterSet, D>(
5560 self.parameter_set
5561 .as_ref()
5562 .map(<HfpParameterSet as fidl::encoding::ValueTypeMarker>::borrow),
5563 encoder,
5564 offset + cur_offset,
5565 depth,
5566 )?;
5567
5568 _prev_end_offset = cur_offset + envelope_size;
5569 if 2 > max_ordinal {
5570 return Ok(());
5571 }
5572
5573 let cur_offset: usize = (2 - 1) * envelope_size;
5576
5577 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5579
5580 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D>(
5585 self.air_coding_format.as_ref().map(<fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::ValueTypeMarker>::borrow),
5586 encoder, offset + cur_offset, depth
5587 )?;
5588
5589 _prev_end_offset = cur_offset + envelope_size;
5590 if 3 > max_ordinal {
5591 return Ok(());
5592 }
5593
5594 let cur_offset: usize = (3 - 1) * envelope_size;
5597
5598 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5600
5601 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5606 self.air_frame_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5607 encoder,
5608 offset + cur_offset,
5609 depth,
5610 )?;
5611
5612 _prev_end_offset = cur_offset + envelope_size;
5613 if 4 > max_ordinal {
5614 return Ok(());
5615 }
5616
5617 let cur_offset: usize = (4 - 1) * envelope_size;
5620
5621 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5623
5624 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5629 self.io_bandwidth.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5630 encoder,
5631 offset + cur_offset,
5632 depth,
5633 )?;
5634
5635 _prev_end_offset = cur_offset + envelope_size;
5636 if 5 > max_ordinal {
5637 return Ok(());
5638 }
5639
5640 let cur_offset: usize = (5 - 1) * envelope_size;
5643
5644 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5646
5647 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D>(
5652 self.io_coding_format.as_ref().map(<fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::ValueTypeMarker>::borrow),
5653 encoder, offset + cur_offset, depth
5654 )?;
5655
5656 _prev_end_offset = cur_offset + envelope_size;
5657 if 6 > max_ordinal {
5658 return Ok(());
5659 }
5660
5661 let cur_offset: usize = (6 - 1) * envelope_size;
5664
5665 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5667
5668 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5673 self.io_frame_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5674 encoder,
5675 offset + cur_offset,
5676 depth,
5677 )?;
5678
5679 _prev_end_offset = cur_offset + envelope_size;
5680 if 7 > max_ordinal {
5681 return Ok(());
5682 }
5683
5684 let cur_offset: usize = (7 - 1) * envelope_size;
5687
5688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5690
5691 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::SampleFormat, D>(
5696 self.io_pcm_data_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::SampleFormat as fidl::encoding::ValueTypeMarker>::borrow),
5697 encoder, offset + cur_offset, depth
5698 )?;
5699
5700 _prev_end_offset = cur_offset + envelope_size;
5701 if 8 > max_ordinal {
5702 return Ok(());
5703 }
5704
5705 let cur_offset: usize = (8 - 1) * envelope_size;
5708
5709 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5711
5712 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5717 self.io_pcm_sample_payload_msb_position
5718 .as_ref()
5719 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5720 encoder,
5721 offset + cur_offset,
5722 depth,
5723 )?;
5724
5725 _prev_end_offset = cur_offset + envelope_size;
5726 if 9 > max_ordinal {
5727 return Ok(());
5728 }
5729
5730 let cur_offset: usize = (9 - 1) * envelope_size;
5733
5734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5736
5737 fidl::encoding::encode_in_envelope_optional::<DataPath, D>(
5742 self.path.as_ref().map(<DataPath as fidl::encoding::ValueTypeMarker>::borrow),
5743 encoder,
5744 offset + cur_offset,
5745 depth,
5746 )?;
5747
5748 _prev_end_offset = cur_offset + envelope_size;
5749 if 10 > max_ordinal {
5750 return Ok(());
5751 }
5752
5753 let cur_offset: usize = (10 - 1) * envelope_size;
5756
5757 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5759
5760 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5765 self.max_tx_data_size
5766 .as_ref()
5767 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5768 encoder,
5769 offset + cur_offset,
5770 depth,
5771 )?;
5772
5773 _prev_end_offset = cur_offset + envelope_size;
5774
5775 Ok(())
5776 }
5777 }
5778
5779 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5780 for ScoConnectionParameters
5781 {
5782 #[inline(always)]
5783 fn new_empty() -> Self {
5784 Self::default()
5785 }
5786
5787 unsafe fn decode(
5788 &mut self,
5789 decoder: &mut fidl::encoding::Decoder<'_, D>,
5790 offset: usize,
5791 mut depth: fidl::encoding::Depth,
5792 ) -> fidl::Result<()> {
5793 decoder.debug_check_bounds::<Self>(offset);
5794 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5795 None => return Err(fidl::Error::NotNullable),
5796 Some(len) => len,
5797 };
5798 if len == 0 {
5800 return Ok(());
5801 };
5802 depth.increment()?;
5803 let envelope_size = 8;
5804 let bytes_len = len * envelope_size;
5805 let offset = decoder.out_of_line_offset(bytes_len)?;
5806 let mut _next_ordinal_to_read = 0;
5808 let mut next_offset = offset;
5809 let end_offset = offset + bytes_len;
5810 _next_ordinal_to_read += 1;
5811 if next_offset >= end_offset {
5812 return Ok(());
5813 }
5814
5815 while _next_ordinal_to_read < 1 {
5817 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5818 _next_ordinal_to_read += 1;
5819 next_offset += envelope_size;
5820 }
5821
5822 let next_out_of_line = decoder.next_out_of_line();
5823 let handles_before = decoder.remaining_handles();
5824 if let Some((inlined, num_bytes, num_handles)) =
5825 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5826 {
5827 let member_inline_size =
5828 <HfpParameterSet as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5829 if inlined != (member_inline_size <= 4) {
5830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5831 }
5832 let inner_offset;
5833 let mut inner_depth = depth.clone();
5834 if inlined {
5835 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5836 inner_offset = next_offset;
5837 } else {
5838 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5839 inner_depth.increment()?;
5840 }
5841 let val_ref =
5842 self.parameter_set.get_or_insert_with(|| fidl::new_empty!(HfpParameterSet, D));
5843 fidl::decode!(HfpParameterSet, D, val_ref, decoder, inner_offset, inner_depth)?;
5844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5845 {
5846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5847 }
5848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5850 }
5851 }
5852
5853 next_offset += envelope_size;
5854 _next_ordinal_to_read += 1;
5855 if next_offset >= end_offset {
5856 return Ok(());
5857 }
5858
5859 while _next_ordinal_to_read < 2 {
5861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5862 _next_ordinal_to_read += 1;
5863 next_offset += envelope_size;
5864 }
5865
5866 let next_out_of_line = decoder.next_out_of_line();
5867 let handles_before = decoder.remaining_handles();
5868 if let Some((inlined, num_bytes, num_handles)) =
5869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5870 {
5871 let member_inline_size = <fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5872 if inlined != (member_inline_size <= 4) {
5873 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5874 }
5875 let inner_offset;
5876 let mut inner_depth = depth.clone();
5877 if inlined {
5878 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5879 inner_offset = next_offset;
5880 } else {
5881 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5882 inner_depth.increment()?;
5883 }
5884 let val_ref = self.air_coding_format.get_or_insert_with(|| {
5885 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D)
5886 });
5887 fidl::decode!(
5888 fidl_fuchsia_bluetooth__common::AssignedCodingFormat,
5889 D,
5890 val_ref,
5891 decoder,
5892 inner_offset,
5893 inner_depth
5894 )?;
5895 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5896 {
5897 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5898 }
5899 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5900 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5901 }
5902 }
5903
5904 next_offset += envelope_size;
5905 _next_ordinal_to_read += 1;
5906 if next_offset >= end_offset {
5907 return Ok(());
5908 }
5909
5910 while _next_ordinal_to_read < 3 {
5912 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5913 _next_ordinal_to_read += 1;
5914 next_offset += envelope_size;
5915 }
5916
5917 let next_out_of_line = decoder.next_out_of_line();
5918 let handles_before = decoder.remaining_handles();
5919 if let Some((inlined, num_bytes, num_handles)) =
5920 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5921 {
5922 let member_inline_size =
5923 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5924 if inlined != (member_inline_size <= 4) {
5925 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5926 }
5927 let inner_offset;
5928 let mut inner_depth = depth.clone();
5929 if inlined {
5930 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5931 inner_offset = next_offset;
5932 } else {
5933 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5934 inner_depth.increment()?;
5935 }
5936 let val_ref = self.air_frame_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
5937 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5938 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5939 {
5940 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5941 }
5942 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5943 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5944 }
5945 }
5946
5947 next_offset += envelope_size;
5948 _next_ordinal_to_read += 1;
5949 if next_offset >= end_offset {
5950 return Ok(());
5951 }
5952
5953 while _next_ordinal_to_read < 4 {
5955 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5956 _next_ordinal_to_read += 1;
5957 next_offset += envelope_size;
5958 }
5959
5960 let next_out_of_line = decoder.next_out_of_line();
5961 let handles_before = decoder.remaining_handles();
5962 if let Some((inlined, num_bytes, num_handles)) =
5963 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5964 {
5965 let member_inline_size =
5966 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5967 if inlined != (member_inline_size <= 4) {
5968 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5969 }
5970 let inner_offset;
5971 let mut inner_depth = depth.clone();
5972 if inlined {
5973 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5974 inner_offset = next_offset;
5975 } else {
5976 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5977 inner_depth.increment()?;
5978 }
5979 let val_ref = self.io_bandwidth.get_or_insert_with(|| fidl::new_empty!(u32, D));
5980 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5981 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5982 {
5983 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5984 }
5985 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5986 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5987 }
5988 }
5989
5990 next_offset += envelope_size;
5991 _next_ordinal_to_read += 1;
5992 if next_offset >= end_offset {
5993 return Ok(());
5994 }
5995
5996 while _next_ordinal_to_read < 5 {
5998 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5999 _next_ordinal_to_read += 1;
6000 next_offset += envelope_size;
6001 }
6002
6003 let next_out_of_line = decoder.next_out_of_line();
6004 let handles_before = decoder.remaining_handles();
6005 if let Some((inlined, num_bytes, num_handles)) =
6006 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6007 {
6008 let member_inline_size = <fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6009 if inlined != (member_inline_size <= 4) {
6010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6011 }
6012 let inner_offset;
6013 let mut inner_depth = depth.clone();
6014 if inlined {
6015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6016 inner_offset = next_offset;
6017 } else {
6018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6019 inner_depth.increment()?;
6020 }
6021 let val_ref = self.io_coding_format.get_or_insert_with(|| {
6022 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D)
6023 });
6024 fidl::decode!(
6025 fidl_fuchsia_bluetooth__common::AssignedCodingFormat,
6026 D,
6027 val_ref,
6028 decoder,
6029 inner_offset,
6030 inner_depth
6031 )?;
6032 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6033 {
6034 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6035 }
6036 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6037 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6038 }
6039 }
6040
6041 next_offset += envelope_size;
6042 _next_ordinal_to_read += 1;
6043 if next_offset >= end_offset {
6044 return Ok(());
6045 }
6046
6047 while _next_ordinal_to_read < 6 {
6049 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6050 _next_ordinal_to_read += 1;
6051 next_offset += envelope_size;
6052 }
6053
6054 let next_out_of_line = decoder.next_out_of_line();
6055 let handles_before = decoder.remaining_handles();
6056 if let Some((inlined, num_bytes, num_handles)) =
6057 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6058 {
6059 let member_inline_size =
6060 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6061 if inlined != (member_inline_size <= 4) {
6062 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6063 }
6064 let inner_offset;
6065 let mut inner_depth = depth.clone();
6066 if inlined {
6067 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6068 inner_offset = next_offset;
6069 } else {
6070 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6071 inner_depth.increment()?;
6072 }
6073 let val_ref = self.io_frame_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
6074 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6075 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6076 {
6077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6078 }
6079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6081 }
6082 }
6083
6084 next_offset += envelope_size;
6085 _next_ordinal_to_read += 1;
6086 if next_offset >= end_offset {
6087 return Ok(());
6088 }
6089
6090 while _next_ordinal_to_read < 7 {
6092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6093 _next_ordinal_to_read += 1;
6094 next_offset += envelope_size;
6095 }
6096
6097 let next_out_of_line = decoder.next_out_of_line();
6098 let handles_before = decoder.remaining_handles();
6099 if let Some((inlined, num_bytes, num_handles)) =
6100 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6101 {
6102 let member_inline_size = <fidl_fuchsia_hardware_audio__common::SampleFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6103 if inlined != (member_inline_size <= 4) {
6104 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6105 }
6106 let inner_offset;
6107 let mut inner_depth = depth.clone();
6108 if inlined {
6109 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6110 inner_offset = next_offset;
6111 } else {
6112 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6113 inner_depth.increment()?;
6114 }
6115 let val_ref = self.io_pcm_data_format.get_or_insert_with(|| {
6116 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::SampleFormat, D)
6117 });
6118 fidl::decode!(
6119 fidl_fuchsia_hardware_audio__common::SampleFormat,
6120 D,
6121 val_ref,
6122 decoder,
6123 inner_offset,
6124 inner_depth
6125 )?;
6126 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6127 {
6128 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6129 }
6130 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6131 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6132 }
6133 }
6134
6135 next_offset += envelope_size;
6136 _next_ordinal_to_read += 1;
6137 if next_offset >= end_offset {
6138 return Ok(());
6139 }
6140
6141 while _next_ordinal_to_read < 8 {
6143 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6144 _next_ordinal_to_read += 1;
6145 next_offset += envelope_size;
6146 }
6147
6148 let next_out_of_line = decoder.next_out_of_line();
6149 let handles_before = decoder.remaining_handles();
6150 if let Some((inlined, num_bytes, num_handles)) =
6151 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6152 {
6153 let member_inline_size =
6154 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6155 if inlined != (member_inline_size <= 4) {
6156 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6157 }
6158 let inner_offset;
6159 let mut inner_depth = depth.clone();
6160 if inlined {
6161 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6162 inner_offset = next_offset;
6163 } else {
6164 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6165 inner_depth.increment()?;
6166 }
6167 let val_ref = self
6168 .io_pcm_sample_payload_msb_position
6169 .get_or_insert_with(|| fidl::new_empty!(u8, D));
6170 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6171 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6172 {
6173 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6174 }
6175 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6176 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6177 }
6178 }
6179
6180 next_offset += envelope_size;
6181 _next_ordinal_to_read += 1;
6182 if next_offset >= end_offset {
6183 return Ok(());
6184 }
6185
6186 while _next_ordinal_to_read < 9 {
6188 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6189 _next_ordinal_to_read += 1;
6190 next_offset += envelope_size;
6191 }
6192
6193 let next_out_of_line = decoder.next_out_of_line();
6194 let handles_before = decoder.remaining_handles();
6195 if let Some((inlined, num_bytes, num_handles)) =
6196 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6197 {
6198 let member_inline_size =
6199 <DataPath as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6200 if inlined != (member_inline_size <= 4) {
6201 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6202 }
6203 let inner_offset;
6204 let mut inner_depth = depth.clone();
6205 if inlined {
6206 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6207 inner_offset = next_offset;
6208 } else {
6209 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6210 inner_depth.increment()?;
6211 }
6212 let val_ref = self.path.get_or_insert_with(|| fidl::new_empty!(DataPath, D));
6213 fidl::decode!(DataPath, D, val_ref, decoder, inner_offset, inner_depth)?;
6214 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6215 {
6216 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6217 }
6218 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6219 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6220 }
6221 }
6222
6223 next_offset += envelope_size;
6224 _next_ordinal_to_read += 1;
6225 if next_offset >= end_offset {
6226 return Ok(());
6227 }
6228
6229 while _next_ordinal_to_read < 10 {
6231 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6232 _next_ordinal_to_read += 1;
6233 next_offset += envelope_size;
6234 }
6235
6236 let next_out_of_line = decoder.next_out_of_line();
6237 let handles_before = decoder.remaining_handles();
6238 if let Some((inlined, num_bytes, num_handles)) =
6239 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6240 {
6241 let member_inline_size =
6242 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6243 if inlined != (member_inline_size <= 4) {
6244 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6245 }
6246 let inner_offset;
6247 let mut inner_depth = depth.clone();
6248 if inlined {
6249 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6250 inner_offset = next_offset;
6251 } else {
6252 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6253 inner_depth.increment()?;
6254 }
6255 let val_ref = self.max_tx_data_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
6256 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6257 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6258 {
6259 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6260 }
6261 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6262 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6263 }
6264 }
6265
6266 next_offset += envelope_size;
6267
6268 while next_offset < end_offset {
6270 _next_ordinal_to_read += 1;
6271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6272 next_offset += envelope_size;
6273 }
6274
6275 Ok(())
6276 }
6277 }
6278
6279 impl ScoConnectionWriteRequest {
6280 #[inline(always)]
6281 fn max_ordinal_present(&self) -> u64 {
6282 if let Some(_) = self.data {
6283 return 1;
6284 }
6285 0
6286 }
6287 }
6288
6289 impl fidl::encoding::ValueTypeMarker for ScoConnectionWriteRequest {
6290 type Borrowed<'a> = &'a Self;
6291 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6292 value
6293 }
6294 }
6295
6296 unsafe impl fidl::encoding::TypeMarker for ScoConnectionWriteRequest {
6297 type Owned = Self;
6298
6299 #[inline(always)]
6300 fn inline_align(_context: fidl::encoding::Context) -> usize {
6301 8
6302 }
6303
6304 #[inline(always)]
6305 fn inline_size(_context: fidl::encoding::Context) -> usize {
6306 16
6307 }
6308 }
6309
6310 unsafe impl<D: fidl::encoding::ResourceDialect>
6311 fidl::encoding::Encode<ScoConnectionWriteRequest, D> for &ScoConnectionWriteRequest
6312 {
6313 unsafe fn encode(
6314 self,
6315 encoder: &mut fidl::encoding::Encoder<'_, D>,
6316 offset: usize,
6317 mut depth: fidl::encoding::Depth,
6318 ) -> fidl::Result<()> {
6319 encoder.debug_check_bounds::<ScoConnectionWriteRequest>(offset);
6320 let max_ordinal: u64 = self.max_ordinal_present();
6322 encoder.write_num(max_ordinal, offset);
6323 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6324 if max_ordinal == 0 {
6326 return Ok(());
6327 }
6328 depth.increment()?;
6329 let envelope_size = 8;
6330 let bytes_len = max_ordinal as usize * envelope_size;
6331 #[allow(unused_variables)]
6332 let offset = encoder.out_of_line_offset(bytes_len);
6333 let mut _prev_end_offset: usize = 0;
6334 if 1 > max_ordinal {
6335 return Ok(());
6336 }
6337
6338 let cur_offset: usize = (1 - 1) * envelope_size;
6341
6342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6344
6345 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6350 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6351 encoder, offset + cur_offset, depth
6352 )?;
6353
6354 _prev_end_offset = cur_offset + envelope_size;
6355
6356 Ok(())
6357 }
6358 }
6359
6360 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6361 for ScoConnectionWriteRequest
6362 {
6363 #[inline(always)]
6364 fn new_empty() -> Self {
6365 Self::default()
6366 }
6367
6368 unsafe fn decode(
6369 &mut self,
6370 decoder: &mut fidl::encoding::Decoder<'_, D>,
6371 offset: usize,
6372 mut depth: fidl::encoding::Depth,
6373 ) -> fidl::Result<()> {
6374 decoder.debug_check_bounds::<Self>(offset);
6375 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6376 None => return Err(fidl::Error::NotNullable),
6377 Some(len) => len,
6378 };
6379 if len == 0 {
6381 return Ok(());
6382 };
6383 depth.increment()?;
6384 let envelope_size = 8;
6385 let bytes_len = len * envelope_size;
6386 let offset = decoder.out_of_line_offset(bytes_len)?;
6387 let mut _next_ordinal_to_read = 0;
6389 let mut next_offset = offset;
6390 let end_offset = offset + bytes_len;
6391 _next_ordinal_to_read += 1;
6392 if next_offset >= end_offset {
6393 return Ok(());
6394 }
6395
6396 while _next_ordinal_to_read < 1 {
6398 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6399 _next_ordinal_to_read += 1;
6400 next_offset += envelope_size;
6401 }
6402
6403 let next_out_of_line = decoder.next_out_of_line();
6404 let handles_before = decoder.remaining_handles();
6405 if let Some((inlined, num_bytes, num_handles)) =
6406 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6407 {
6408 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6409 if inlined != (member_inline_size <= 4) {
6410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6411 }
6412 let inner_offset;
6413 let mut inner_depth = depth.clone();
6414 if inlined {
6415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6416 inner_offset = next_offset;
6417 } else {
6418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6419 inner_depth.increment()?;
6420 }
6421 let val_ref = self.data.get_or_insert_with(|| {
6422 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6423 });
6424 fidl::decode!(
6425 fidl::encoding::UnboundedVector<u8>,
6426 D,
6427 val_ref,
6428 decoder,
6429 inner_offset,
6430 inner_depth
6431 )?;
6432 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6433 {
6434 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6435 }
6436 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6437 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6438 }
6439 }
6440
6441 next_offset += envelope_size;
6442
6443 while next_offset < end_offset {
6445 _next_ordinal_to_read += 1;
6446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6447 next_offset += envelope_size;
6448 }
6449
6450 Ok(())
6451 }
6452 }
6453
6454 impl ScoConnectionReadResponse {
6455 #[inline(always)]
6456 fn max_ordinal_present(&self) -> u64 {
6457 if let Some(_) = self.data {
6458 return 2;
6459 }
6460 if let Some(_) = self.status_flag {
6461 return 1;
6462 }
6463 0
6464 }
6465 }
6466
6467 impl fidl::encoding::ValueTypeMarker for ScoConnectionReadResponse {
6468 type Borrowed<'a> = &'a Self;
6469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6470 value
6471 }
6472 }
6473
6474 unsafe impl fidl::encoding::TypeMarker for ScoConnectionReadResponse {
6475 type Owned = Self;
6476
6477 #[inline(always)]
6478 fn inline_align(_context: fidl::encoding::Context) -> usize {
6479 8
6480 }
6481
6482 #[inline(always)]
6483 fn inline_size(_context: fidl::encoding::Context) -> usize {
6484 16
6485 }
6486 }
6487
6488 unsafe impl<D: fidl::encoding::ResourceDialect>
6489 fidl::encoding::Encode<ScoConnectionReadResponse, D> for &ScoConnectionReadResponse
6490 {
6491 unsafe fn encode(
6492 self,
6493 encoder: &mut fidl::encoding::Encoder<'_, D>,
6494 offset: usize,
6495 mut depth: fidl::encoding::Depth,
6496 ) -> fidl::Result<()> {
6497 encoder.debug_check_bounds::<ScoConnectionReadResponse>(offset);
6498 let max_ordinal: u64 = self.max_ordinal_present();
6500 encoder.write_num(max_ordinal, offset);
6501 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6502 if max_ordinal == 0 {
6504 return Ok(());
6505 }
6506 depth.increment()?;
6507 let envelope_size = 8;
6508 let bytes_len = max_ordinal as usize * envelope_size;
6509 #[allow(unused_variables)]
6510 let offset = encoder.out_of_line_offset(bytes_len);
6511 let mut _prev_end_offset: usize = 0;
6512 if 1 > max_ordinal {
6513 return Ok(());
6514 }
6515
6516 let cur_offset: usize = (1 - 1) * envelope_size;
6519
6520 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6522
6523 fidl::encoding::encode_in_envelope_optional::<RxPacketStatus, D>(
6528 self.status_flag
6529 .as_ref()
6530 .map(<RxPacketStatus as fidl::encoding::ValueTypeMarker>::borrow),
6531 encoder,
6532 offset + cur_offset,
6533 depth,
6534 )?;
6535
6536 _prev_end_offset = cur_offset + envelope_size;
6537 if 2 > max_ordinal {
6538 return Ok(());
6539 }
6540
6541 let cur_offset: usize = (2 - 1) * envelope_size;
6544
6545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6547
6548 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6553 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6554 encoder, offset + cur_offset, depth
6555 )?;
6556
6557 _prev_end_offset = cur_offset + envelope_size;
6558
6559 Ok(())
6560 }
6561 }
6562
6563 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6564 for ScoConnectionReadResponse
6565 {
6566 #[inline(always)]
6567 fn new_empty() -> Self {
6568 Self::default()
6569 }
6570
6571 unsafe fn decode(
6572 &mut self,
6573 decoder: &mut fidl::encoding::Decoder<'_, D>,
6574 offset: usize,
6575 mut depth: fidl::encoding::Depth,
6576 ) -> fidl::Result<()> {
6577 decoder.debug_check_bounds::<Self>(offset);
6578 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6579 None => return Err(fidl::Error::NotNullable),
6580 Some(len) => len,
6581 };
6582 if len == 0 {
6584 return Ok(());
6585 };
6586 depth.increment()?;
6587 let envelope_size = 8;
6588 let bytes_len = len * envelope_size;
6589 let offset = decoder.out_of_line_offset(bytes_len)?;
6590 let mut _next_ordinal_to_read = 0;
6592 let mut next_offset = offset;
6593 let end_offset = offset + bytes_len;
6594 _next_ordinal_to_read += 1;
6595 if next_offset >= end_offset {
6596 return Ok(());
6597 }
6598
6599 while _next_ordinal_to_read < 1 {
6601 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6602 _next_ordinal_to_read += 1;
6603 next_offset += envelope_size;
6604 }
6605
6606 let next_out_of_line = decoder.next_out_of_line();
6607 let handles_before = decoder.remaining_handles();
6608 if let Some((inlined, num_bytes, num_handles)) =
6609 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6610 {
6611 let member_inline_size =
6612 <RxPacketStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6613 if inlined != (member_inline_size <= 4) {
6614 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6615 }
6616 let inner_offset;
6617 let mut inner_depth = depth.clone();
6618 if inlined {
6619 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6620 inner_offset = next_offset;
6621 } else {
6622 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6623 inner_depth.increment()?;
6624 }
6625 let val_ref =
6626 self.status_flag.get_or_insert_with(|| fidl::new_empty!(RxPacketStatus, D));
6627 fidl::decode!(RxPacketStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
6628 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6629 {
6630 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6631 }
6632 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6633 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6634 }
6635 }
6636
6637 next_offset += envelope_size;
6638 _next_ordinal_to_read += 1;
6639 if next_offset >= end_offset {
6640 return Ok(());
6641 }
6642
6643 while _next_ordinal_to_read < 2 {
6645 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6646 _next_ordinal_to_read += 1;
6647 next_offset += envelope_size;
6648 }
6649
6650 let next_out_of_line = decoder.next_out_of_line();
6651 let handles_before = decoder.remaining_handles();
6652 if let Some((inlined, num_bytes, num_handles)) =
6653 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6654 {
6655 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6656 if inlined != (member_inline_size <= 4) {
6657 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6658 }
6659 let inner_offset;
6660 let mut inner_depth = depth.clone();
6661 if inlined {
6662 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6663 inner_offset = next_offset;
6664 } else {
6665 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6666 inner_depth.increment()?;
6667 }
6668 let val_ref = self.data.get_or_insert_with(|| {
6669 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6670 });
6671 fidl::decode!(
6672 fidl::encoding::UnboundedVector<u8>,
6673 D,
6674 val_ref,
6675 decoder,
6676 inner_offset,
6677 inner_depth
6678 )?;
6679 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6680 {
6681 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6682 }
6683 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6684 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6685 }
6686 }
6687
6688 next_offset += envelope_size;
6689
6690 while next_offset < end_offset {
6692 _next_ordinal_to_read += 1;
6693 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6694 next_offset += envelope_size;
6695 }
6696
6697 Ok(())
6698 }
6699 }
6700
6701 impl ServiceDefinition {
6702 #[inline(always)]
6703 fn max_ordinal_present(&self) -> u64 {
6704 if let Some(_) = self.additional_attributes {
6705 return 6;
6706 }
6707 if let Some(_) = self.information {
6708 return 5;
6709 }
6710 if let Some(_) = self.profile_descriptors {
6711 return 4;
6712 }
6713 if let Some(_) = self.additional_protocol_descriptor_lists {
6714 return 3;
6715 }
6716 if let Some(_) = self.protocol_descriptor_list {
6717 return 2;
6718 }
6719 if let Some(_) = self.service_class_uuids {
6720 return 1;
6721 }
6722 0
6723 }
6724 }
6725
6726 impl fidl::encoding::ValueTypeMarker for ServiceDefinition {
6727 type Borrowed<'a> = &'a Self;
6728 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6729 value
6730 }
6731 }
6732
6733 unsafe impl fidl::encoding::TypeMarker for ServiceDefinition {
6734 type Owned = Self;
6735
6736 #[inline(always)]
6737 fn inline_align(_context: fidl::encoding::Context) -> usize {
6738 8
6739 }
6740
6741 #[inline(always)]
6742 fn inline_size(_context: fidl::encoding::Context) -> usize {
6743 16
6744 }
6745 }
6746
6747 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDefinition, D>
6748 for &ServiceDefinition
6749 {
6750 unsafe fn encode(
6751 self,
6752 encoder: &mut fidl::encoding::Encoder<'_, D>,
6753 offset: usize,
6754 mut depth: fidl::encoding::Depth,
6755 ) -> fidl::Result<()> {
6756 encoder.debug_check_bounds::<ServiceDefinition>(offset);
6757 let max_ordinal: u64 = self.max_ordinal_present();
6759 encoder.write_num(max_ordinal, offset);
6760 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6761 if max_ordinal == 0 {
6763 return Ok(());
6764 }
6765 depth.increment()?;
6766 let envelope_size = 8;
6767 let bytes_len = max_ordinal as usize * envelope_size;
6768 #[allow(unused_variables)]
6769 let offset = encoder.out_of_line_offset(bytes_len);
6770 let mut _prev_end_offset: usize = 0;
6771 if 1 > max_ordinal {
6772 return Ok(());
6773 }
6774
6775 let cur_offset: usize = (1 - 1) * envelope_size;
6778
6779 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6781
6782 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D>(
6787 self.service_class_uuids.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6788 encoder, offset + cur_offset, depth
6789 )?;
6790
6791 _prev_end_offset = cur_offset + envelope_size;
6792 if 2 > max_ordinal {
6793 return Ok(());
6794 }
6795
6796 let cur_offset: usize = (2 - 1) * envelope_size;
6799
6800 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6802
6803 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProtocolDescriptor, 255>, D>(
6808 self.protocol_descriptor_list.as_ref().map(<fidl::encoding::Vector<ProtocolDescriptor, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6809 encoder, offset + cur_offset, depth
6810 )?;
6811
6812 _prev_end_offset = cur_offset + envelope_size;
6813 if 3 > max_ordinal {
6814 return Ok(());
6815 }
6816
6817 let cur_offset: usize = (3 - 1) * envelope_size;
6820
6821 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6823
6824 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255>, D>(
6829 self.additional_protocol_descriptor_lists.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6830 encoder, offset + cur_offset, depth
6831 )?;
6832
6833 _prev_end_offset = cur_offset + envelope_size;
6834 if 4 > max_ordinal {
6835 return Ok(());
6836 }
6837
6838 let cur_offset: usize = (4 - 1) * envelope_size;
6841
6842 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6844
6845 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProfileDescriptor, 255>, D>(
6850 self.profile_descriptors.as_ref().map(<fidl::encoding::Vector<ProfileDescriptor, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6851 encoder, offset + cur_offset, depth
6852 )?;
6853
6854 _prev_end_offset = cur_offset + envelope_size;
6855 if 5 > max_ordinal {
6856 return Ok(());
6857 }
6858
6859 let cur_offset: usize = (5 - 1) * envelope_size;
6862
6863 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6865
6866 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Information, 85>, D>(
6871 self.information.as_ref().map(<fidl::encoding::Vector<Information, 85> as fidl::encoding::ValueTypeMarker>::borrow),
6872 encoder, offset + cur_offset, depth
6873 )?;
6874
6875 _prev_end_offset = cur_offset + envelope_size;
6876 if 6 > max_ordinal {
6877 return Ok(());
6878 }
6879
6880 let cur_offset: usize = (6 - 1) * envelope_size;
6883
6884 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6886
6887 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Attribute, 65023>, D>(
6892 self.additional_attributes.as_ref().map(<fidl::encoding::Vector<Attribute, 65023> as fidl::encoding::ValueTypeMarker>::borrow),
6893 encoder, offset + cur_offset, depth
6894 )?;
6895
6896 _prev_end_offset = cur_offset + envelope_size;
6897
6898 Ok(())
6899 }
6900 }
6901
6902 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDefinition {
6903 #[inline(always)]
6904 fn new_empty() -> Self {
6905 Self::default()
6906 }
6907
6908 unsafe fn decode(
6909 &mut self,
6910 decoder: &mut fidl::encoding::Decoder<'_, D>,
6911 offset: usize,
6912 mut depth: fidl::encoding::Depth,
6913 ) -> fidl::Result<()> {
6914 decoder.debug_check_bounds::<Self>(offset);
6915 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6916 None => return Err(fidl::Error::NotNullable),
6917 Some(len) => len,
6918 };
6919 if len == 0 {
6921 return Ok(());
6922 };
6923 depth.increment()?;
6924 let envelope_size = 8;
6925 let bytes_len = len * envelope_size;
6926 let offset = decoder.out_of_line_offset(bytes_len)?;
6927 let mut _next_ordinal_to_read = 0;
6929 let mut next_offset = offset;
6930 let end_offset = offset + bytes_len;
6931 _next_ordinal_to_read += 1;
6932 if next_offset >= end_offset {
6933 return Ok(());
6934 }
6935
6936 while _next_ordinal_to_read < 1 {
6938 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6939 _next_ordinal_to_read += 1;
6940 next_offset += envelope_size;
6941 }
6942
6943 let next_out_of_line = decoder.next_out_of_line();
6944 let handles_before = decoder.remaining_handles();
6945 if let Some((inlined, num_bytes, num_handles)) =
6946 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6947 {
6948 let member_inline_size = <fidl::encoding::Vector<
6949 fidl_fuchsia_bluetooth__common::Uuid,
6950 255,
6951 > as fidl::encoding::TypeMarker>::inline_size(
6952 decoder.context
6953 );
6954 if inlined != (member_inline_size <= 4) {
6955 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6956 }
6957 let inner_offset;
6958 let mut inner_depth = depth.clone();
6959 if inlined {
6960 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6961 inner_offset = next_offset;
6962 } else {
6963 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6964 inner_depth.increment()?;
6965 }
6966 let val_ref =
6967 self.service_class_uuids.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D));
6968 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
6969 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6970 {
6971 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6972 }
6973 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6974 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6975 }
6976 }
6977
6978 next_offset += envelope_size;
6979 _next_ordinal_to_read += 1;
6980 if next_offset >= end_offset {
6981 return Ok(());
6982 }
6983
6984 while _next_ordinal_to_read < 2 {
6986 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6987 _next_ordinal_to_read += 1;
6988 next_offset += envelope_size;
6989 }
6990
6991 let next_out_of_line = decoder.next_out_of_line();
6992 let handles_before = decoder.remaining_handles();
6993 if let Some((inlined, num_bytes, num_handles)) =
6994 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6995 {
6996 let member_inline_size = <fidl::encoding::Vector<ProtocolDescriptor, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6997 if inlined != (member_inline_size <= 4) {
6998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6999 }
7000 let inner_offset;
7001 let mut inner_depth = depth.clone();
7002 if inlined {
7003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7004 inner_offset = next_offset;
7005 } else {
7006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7007 inner_depth.increment()?;
7008 }
7009 let val_ref = self.protocol_descriptor_list.get_or_insert_with(
7010 || fidl::new_empty!(fidl::encoding::Vector<ProtocolDescriptor, 255>, D),
7011 );
7012 fidl::decode!(fidl::encoding::Vector<ProtocolDescriptor, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7013 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7014 {
7015 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7016 }
7017 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7018 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7019 }
7020 }
7021
7022 next_offset += envelope_size;
7023 _next_ordinal_to_read += 1;
7024 if next_offset >= end_offset {
7025 return Ok(());
7026 }
7027
7028 while _next_ordinal_to_read < 3 {
7030 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7031 _next_ordinal_to_read += 1;
7032 next_offset += envelope_size;
7033 }
7034
7035 let next_out_of_line = decoder.next_out_of_line();
7036 let handles_before = decoder.remaining_handles();
7037 if let Some((inlined, num_bytes, num_handles)) =
7038 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7039 {
7040 let member_inline_size = <fidl::encoding::Vector<
7041 fidl::encoding::Vector<ProtocolDescriptor, 255>,
7042 255,
7043 > as fidl::encoding::TypeMarker>::inline_size(
7044 decoder.context
7045 );
7046 if inlined != (member_inline_size <= 4) {
7047 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7048 }
7049 let inner_offset;
7050 let mut inner_depth = depth.clone();
7051 if inlined {
7052 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7053 inner_offset = next_offset;
7054 } else {
7055 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7056 inner_depth.increment()?;
7057 }
7058 let val_ref = self.additional_protocol_descriptor_lists.get_or_insert_with(|| {
7059 fidl::new_empty!(
7060 fidl::encoding::Vector<
7061 fidl::encoding::Vector<ProtocolDescriptor, 255>,
7062 255,
7063 >,
7064 D
7065 )
7066 });
7067 fidl::decode!(
7068 fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255>,
7069 D,
7070 val_ref,
7071 decoder,
7072 inner_offset,
7073 inner_depth
7074 )?;
7075 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7076 {
7077 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7078 }
7079 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7080 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7081 }
7082 }
7083
7084 next_offset += envelope_size;
7085 _next_ordinal_to_read += 1;
7086 if next_offset >= end_offset {
7087 return Ok(());
7088 }
7089
7090 while _next_ordinal_to_read < 4 {
7092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7093 _next_ordinal_to_read += 1;
7094 next_offset += envelope_size;
7095 }
7096
7097 let next_out_of_line = decoder.next_out_of_line();
7098 let handles_before = decoder.remaining_handles();
7099 if let Some((inlined, num_bytes, num_handles)) =
7100 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7101 {
7102 let member_inline_size = <fidl::encoding::Vector<ProfileDescriptor, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7103 if inlined != (member_inline_size <= 4) {
7104 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7105 }
7106 let inner_offset;
7107 let mut inner_depth = depth.clone();
7108 if inlined {
7109 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7110 inner_offset = next_offset;
7111 } else {
7112 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7113 inner_depth.increment()?;
7114 }
7115 let val_ref = self.profile_descriptors.get_or_insert_with(
7116 || fidl::new_empty!(fidl::encoding::Vector<ProfileDescriptor, 255>, D),
7117 );
7118 fidl::decode!(fidl::encoding::Vector<ProfileDescriptor, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7119 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7120 {
7121 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7122 }
7123 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7124 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7125 }
7126 }
7127
7128 next_offset += envelope_size;
7129 _next_ordinal_to_read += 1;
7130 if next_offset >= end_offset {
7131 return Ok(());
7132 }
7133
7134 while _next_ordinal_to_read < 5 {
7136 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7137 _next_ordinal_to_read += 1;
7138 next_offset += envelope_size;
7139 }
7140
7141 let next_out_of_line = decoder.next_out_of_line();
7142 let handles_before = decoder.remaining_handles();
7143 if let Some((inlined, num_bytes, num_handles)) =
7144 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7145 {
7146 let member_inline_size = <fidl::encoding::Vector<Information, 85> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7147 if inlined != (member_inline_size <= 4) {
7148 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7149 }
7150 let inner_offset;
7151 let mut inner_depth = depth.clone();
7152 if inlined {
7153 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7154 inner_offset = next_offset;
7155 } else {
7156 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7157 inner_depth.increment()?;
7158 }
7159 let val_ref = self.information.get_or_insert_with(
7160 || fidl::new_empty!(fidl::encoding::Vector<Information, 85>, D),
7161 );
7162 fidl::decode!(fidl::encoding::Vector<Information, 85>, D, val_ref, decoder, inner_offset, inner_depth)?;
7163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7164 {
7165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7166 }
7167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7169 }
7170 }
7171
7172 next_offset += envelope_size;
7173 _next_ordinal_to_read += 1;
7174 if next_offset >= end_offset {
7175 return Ok(());
7176 }
7177
7178 while _next_ordinal_to_read < 6 {
7180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7181 _next_ordinal_to_read += 1;
7182 next_offset += envelope_size;
7183 }
7184
7185 let next_out_of_line = decoder.next_out_of_line();
7186 let handles_before = decoder.remaining_handles();
7187 if let Some((inlined, num_bytes, num_handles)) =
7188 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7189 {
7190 let member_inline_size = <fidl::encoding::Vector<Attribute, 65023> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7191 if inlined != (member_inline_size <= 4) {
7192 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7193 }
7194 let inner_offset;
7195 let mut inner_depth = depth.clone();
7196 if inlined {
7197 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7198 inner_offset = next_offset;
7199 } else {
7200 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7201 inner_depth.increment()?;
7202 }
7203 let val_ref = self.additional_attributes.get_or_insert_with(
7204 || fidl::new_empty!(fidl::encoding::Vector<Attribute, 65023>, D),
7205 );
7206 fidl::decode!(fidl::encoding::Vector<Attribute, 65023>, D, val_ref, decoder, inner_offset, inner_depth)?;
7207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7208 {
7209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7210 }
7211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7213 }
7214 }
7215
7216 next_offset += envelope_size;
7217
7218 while next_offset < end_offset {
7220 _next_ordinal_to_read += 1;
7221 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7222 next_offset += envelope_size;
7223 }
7224
7225 Ok(())
7226 }
7227 }
7228
7229 impl fidl::encoding::ValueTypeMarker for AudioEncoderSettings {
7230 type Borrowed<'a> = &'a Self;
7231 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7232 value
7233 }
7234 }
7235
7236 unsafe impl fidl::encoding::TypeMarker for AudioEncoderSettings {
7237 type Owned = Self;
7238
7239 #[inline(always)]
7240 fn inline_align(_context: fidl::encoding::Context) -> usize {
7241 8
7242 }
7243
7244 #[inline(always)]
7245 fn inline_size(_context: fidl::encoding::Context) -> usize {
7246 16
7247 }
7248 }
7249
7250 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioEncoderSettings, D>
7251 for &AudioEncoderSettings
7252 {
7253 #[inline]
7254 unsafe fn encode(
7255 self,
7256 encoder: &mut fidl::encoding::Encoder<'_, D>,
7257 offset: usize,
7258 _depth: fidl::encoding::Depth,
7259 ) -> fidl::Result<()> {
7260 encoder.debug_check_bounds::<AudioEncoderSettings>(offset);
7261 encoder.write_num::<u64>(self.ordinal(), offset);
7262 match self {
7263 AudioEncoderSettings::Sbc(ref val) => {
7264 fidl::encoding::encode_in_envelope::<fidl_fuchsia_media__common::SbcEncoderSettings, D>(
7265 <fidl_fuchsia_media__common::SbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
7266 encoder, offset + 8, _depth
7267 )
7268 }
7269 AudioEncoderSettings::Aac(ref val) => {
7270 fidl::encoding::encode_in_envelope::<fidl_fuchsia_media__common::AacEncoderSettings, D>(
7271 <fidl_fuchsia_media__common::AacEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
7272 encoder, offset + 8, _depth
7273 )
7274 }
7275 AudioEncoderSettings::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7276 }
7277 }
7278 }
7279
7280 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioEncoderSettings {
7281 #[inline(always)]
7282 fn new_empty() -> Self {
7283 Self::__SourceBreaking { unknown_ordinal: 0 }
7284 }
7285
7286 #[inline]
7287 unsafe fn decode(
7288 &mut self,
7289 decoder: &mut fidl::encoding::Decoder<'_, D>,
7290 offset: usize,
7291 mut depth: fidl::encoding::Depth,
7292 ) -> fidl::Result<()> {
7293 decoder.debug_check_bounds::<Self>(offset);
7294 #[allow(unused_variables)]
7295 let next_out_of_line = decoder.next_out_of_line();
7296 let handles_before = decoder.remaining_handles();
7297 let (ordinal, inlined, num_bytes, num_handles) =
7298 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7299
7300 let member_inline_size = match ordinal {
7301 1 => <fidl_fuchsia_media__common::SbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7302 2 => <fidl_fuchsia_media__common::AacEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7303 0 => return Err(fidl::Error::UnknownUnionTag),
7304 _ => num_bytes as usize,
7305 };
7306
7307 if inlined != (member_inline_size <= 4) {
7308 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7309 }
7310 let _inner_offset;
7311 if inlined {
7312 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7313 _inner_offset = offset + 8;
7314 } else {
7315 depth.increment()?;
7316 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7317 }
7318 match ordinal {
7319 1 => {
7320 #[allow(irrefutable_let_patterns)]
7321 if let AudioEncoderSettings::Sbc(_) = self {
7322 } else {
7324 *self = AudioEncoderSettings::Sbc(fidl::new_empty!(
7326 fidl_fuchsia_media__common::SbcEncoderSettings,
7327 D
7328 ));
7329 }
7330 #[allow(irrefutable_let_patterns)]
7331 if let AudioEncoderSettings::Sbc(ref mut val) = self {
7332 fidl::decode!(
7333 fidl_fuchsia_media__common::SbcEncoderSettings,
7334 D,
7335 val,
7336 decoder,
7337 _inner_offset,
7338 depth
7339 )?;
7340 } else {
7341 unreachable!()
7342 }
7343 }
7344 2 => {
7345 #[allow(irrefutable_let_patterns)]
7346 if let AudioEncoderSettings::Aac(_) = self {
7347 } else {
7349 *self = AudioEncoderSettings::Aac(fidl::new_empty!(
7351 fidl_fuchsia_media__common::AacEncoderSettings,
7352 D
7353 ));
7354 }
7355 #[allow(irrefutable_let_patterns)]
7356 if let AudioEncoderSettings::Aac(ref mut val) = self {
7357 fidl::decode!(
7358 fidl_fuchsia_media__common::AacEncoderSettings,
7359 D,
7360 val,
7361 decoder,
7362 _inner_offset,
7363 depth
7364 )?;
7365 } else {
7366 unreachable!()
7367 }
7368 }
7369 #[allow(deprecated)]
7370 ordinal => {
7371 for _ in 0..num_handles {
7372 decoder.drop_next_handle()?;
7373 }
7374 *self = AudioEncoderSettings::__SourceBreaking { unknown_ordinal: ordinal };
7375 }
7376 }
7377 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7378 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7379 }
7380 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7381 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7382 }
7383 Ok(())
7384 }
7385 }
7386
7387 impl fidl::encoding::ValueTypeMarker for AudioOffloadFeatures {
7388 type Borrowed<'a> = &'a Self;
7389 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7390 value
7391 }
7392 }
7393
7394 unsafe impl fidl::encoding::TypeMarker for AudioOffloadFeatures {
7395 type Owned = Self;
7396
7397 #[inline(always)]
7398 fn inline_align(_context: fidl::encoding::Context) -> usize {
7399 8
7400 }
7401
7402 #[inline(always)]
7403 fn inline_size(_context: fidl::encoding::Context) -> usize {
7404 16
7405 }
7406 }
7407
7408 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioOffloadFeatures, D>
7409 for &AudioOffloadFeatures
7410 {
7411 #[inline]
7412 unsafe fn encode(
7413 self,
7414 encoder: &mut fidl::encoding::Encoder<'_, D>,
7415 offset: usize,
7416 _depth: fidl::encoding::Depth,
7417 ) -> fidl::Result<()> {
7418 encoder.debug_check_bounds::<AudioOffloadFeatures>(offset);
7419 encoder.write_num::<u64>(self.ordinal(), offset);
7420 match self {
7421 AudioOffloadFeatures::Sbc(ref val) => {
7422 fidl::encoding::encode_in_envelope::<AudioSbcSupport, D>(
7423 <AudioSbcSupport as fidl::encoding::ValueTypeMarker>::borrow(val),
7424 encoder,
7425 offset + 8,
7426 _depth,
7427 )
7428 }
7429 AudioOffloadFeatures::Aac(ref val) => {
7430 fidl::encoding::encode_in_envelope::<AudioAacSupport, D>(
7431 <AudioAacSupport as fidl::encoding::ValueTypeMarker>::borrow(val),
7432 encoder,
7433 offset + 8,
7434 _depth,
7435 )
7436 }
7437 AudioOffloadFeatures::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7438 }
7439 }
7440 }
7441
7442 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioOffloadFeatures {
7443 #[inline(always)]
7444 fn new_empty() -> Self {
7445 Self::__SourceBreaking { unknown_ordinal: 0 }
7446 }
7447
7448 #[inline]
7449 unsafe fn decode(
7450 &mut self,
7451 decoder: &mut fidl::encoding::Decoder<'_, D>,
7452 offset: usize,
7453 mut depth: fidl::encoding::Depth,
7454 ) -> fidl::Result<()> {
7455 decoder.debug_check_bounds::<Self>(offset);
7456 #[allow(unused_variables)]
7457 let next_out_of_line = decoder.next_out_of_line();
7458 let handles_before = decoder.remaining_handles();
7459 let (ordinal, inlined, num_bytes, num_handles) =
7460 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7461
7462 let member_inline_size = match ordinal {
7463 1 => <AudioSbcSupport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7464 2 => <AudioAacSupport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7465 0 => return Err(fidl::Error::UnknownUnionTag),
7466 _ => num_bytes as usize,
7467 };
7468
7469 if inlined != (member_inline_size <= 4) {
7470 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7471 }
7472 let _inner_offset;
7473 if inlined {
7474 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7475 _inner_offset = offset + 8;
7476 } else {
7477 depth.increment()?;
7478 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7479 }
7480 match ordinal {
7481 1 => {
7482 #[allow(irrefutable_let_patterns)]
7483 if let AudioOffloadFeatures::Sbc(_) = self {
7484 } else {
7486 *self = AudioOffloadFeatures::Sbc(fidl::new_empty!(AudioSbcSupport, D));
7488 }
7489 #[allow(irrefutable_let_patterns)]
7490 if let AudioOffloadFeatures::Sbc(ref mut val) = self {
7491 fidl::decode!(AudioSbcSupport, D, val, decoder, _inner_offset, depth)?;
7492 } else {
7493 unreachable!()
7494 }
7495 }
7496 2 => {
7497 #[allow(irrefutable_let_patterns)]
7498 if let AudioOffloadFeatures::Aac(_) = self {
7499 } else {
7501 *self = AudioOffloadFeatures::Aac(fidl::new_empty!(AudioAacSupport, D));
7503 }
7504 #[allow(irrefutable_let_patterns)]
7505 if let AudioOffloadFeatures::Aac(ref mut val) = self {
7506 fidl::decode!(AudioAacSupport, D, val, decoder, _inner_offset, depth)?;
7507 } else {
7508 unreachable!()
7509 }
7510 }
7511 #[allow(deprecated)]
7512 ordinal => {
7513 for _ in 0..num_handles {
7514 decoder.drop_next_handle()?;
7515 }
7516 *self = AudioOffloadFeatures::__SourceBreaking { unknown_ordinal: ordinal };
7517 }
7518 }
7519 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7520 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7521 }
7522 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7523 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7524 }
7525 Ok(())
7526 }
7527 }
7528
7529 impl fidl::encoding::ValueTypeMarker for ConnectParameters {
7530 type Borrowed<'a> = &'a Self;
7531 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7532 value
7533 }
7534 }
7535
7536 unsafe impl fidl::encoding::TypeMarker for ConnectParameters {
7537 type Owned = Self;
7538
7539 #[inline(always)]
7540 fn inline_align(_context: fidl::encoding::Context) -> usize {
7541 8
7542 }
7543
7544 #[inline(always)]
7545 fn inline_size(_context: fidl::encoding::Context) -> usize {
7546 16
7547 }
7548 }
7549
7550 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectParameters, D>
7551 for &ConnectParameters
7552 {
7553 #[inline]
7554 unsafe fn encode(
7555 self,
7556 encoder: &mut fidl::encoding::Encoder<'_, D>,
7557 offset: usize,
7558 _depth: fidl::encoding::Depth,
7559 ) -> fidl::Result<()> {
7560 encoder.debug_check_bounds::<ConnectParameters>(offset);
7561 encoder.write_num::<u64>(self.ordinal(), offset);
7562 match self {
7563 ConnectParameters::L2cap(ref val) => {
7564 fidl::encoding::encode_in_envelope::<L2capParameters, D>(
7565 <L2capParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
7566 encoder,
7567 offset + 8,
7568 _depth,
7569 )
7570 }
7571 ConnectParameters::Rfcomm(ref val) => {
7572 fidl::encoding::encode_in_envelope::<RfcommParameters, D>(
7573 <RfcommParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
7574 encoder,
7575 offset + 8,
7576 _depth,
7577 )
7578 }
7579 }
7580 }
7581 }
7582
7583 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectParameters {
7584 #[inline(always)]
7585 fn new_empty() -> Self {
7586 Self::L2cap(fidl::new_empty!(L2capParameters, D))
7587 }
7588
7589 #[inline]
7590 unsafe fn decode(
7591 &mut self,
7592 decoder: &mut fidl::encoding::Decoder<'_, D>,
7593 offset: usize,
7594 mut depth: fidl::encoding::Depth,
7595 ) -> fidl::Result<()> {
7596 decoder.debug_check_bounds::<Self>(offset);
7597 #[allow(unused_variables)]
7598 let next_out_of_line = decoder.next_out_of_line();
7599 let handles_before = decoder.remaining_handles();
7600 let (ordinal, inlined, num_bytes, num_handles) =
7601 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7602
7603 let member_inline_size = match ordinal {
7604 1 => <L2capParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7605 2 => <RfcommParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7606 _ => return Err(fidl::Error::UnknownUnionTag),
7607 };
7608
7609 if inlined != (member_inline_size <= 4) {
7610 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7611 }
7612 let _inner_offset;
7613 if inlined {
7614 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7615 _inner_offset = offset + 8;
7616 } else {
7617 depth.increment()?;
7618 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7619 }
7620 match ordinal {
7621 1 => {
7622 #[allow(irrefutable_let_patterns)]
7623 if let ConnectParameters::L2cap(_) = self {
7624 } else {
7626 *self = ConnectParameters::L2cap(fidl::new_empty!(L2capParameters, D));
7628 }
7629 #[allow(irrefutable_let_patterns)]
7630 if let ConnectParameters::L2cap(ref mut val) = self {
7631 fidl::decode!(L2capParameters, D, val, decoder, _inner_offset, depth)?;
7632 } else {
7633 unreachable!()
7634 }
7635 }
7636 2 => {
7637 #[allow(irrefutable_let_patterns)]
7638 if let ConnectParameters::Rfcomm(_) = self {
7639 } else {
7641 *self = ConnectParameters::Rfcomm(fidl::new_empty!(RfcommParameters, D));
7643 }
7644 #[allow(irrefutable_let_patterns)]
7645 if let ConnectParameters::Rfcomm(ref mut val) = self {
7646 fidl::decode!(RfcommParameters, D, val, decoder, _inner_offset, depth)?;
7647 } else {
7648 unreachable!()
7649 }
7650 }
7651 ordinal => panic!("unexpected ordinal {:?}", ordinal),
7652 }
7653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7654 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7655 }
7656 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7657 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7658 }
7659 Ok(())
7660 }
7661 }
7662
7663 impl fidl::encoding::ValueTypeMarker for DataElement {
7664 type Borrowed<'a> = &'a Self;
7665 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7666 value
7667 }
7668 }
7669
7670 unsafe impl fidl::encoding::TypeMarker for DataElement {
7671 type Owned = Self;
7672
7673 #[inline(always)]
7674 fn inline_align(_context: fidl::encoding::Context) -> usize {
7675 8
7676 }
7677
7678 #[inline(always)]
7679 fn inline_size(_context: fidl::encoding::Context) -> usize {
7680 16
7681 }
7682 }
7683
7684 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DataElement, D>
7685 for &DataElement
7686 {
7687 #[inline]
7688 unsafe fn encode(
7689 self,
7690 encoder: &mut fidl::encoding::Encoder<'_, D>,
7691 offset: usize,
7692 _depth: fidl::encoding::Depth,
7693 ) -> fidl::Result<()> {
7694 encoder.debug_check_bounds::<DataElement>(offset);
7695 encoder.write_num::<u64>(self.ordinal(), offset);
7696 match self {
7697 DataElement::Int8(ref val) => {
7698 fidl::encoding::encode_in_envelope::<i8, D>(
7699 <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
7700 encoder, offset + 8, _depth
7701 )
7702 }
7703 DataElement::Int16(ref val) => {
7704 fidl::encoding::encode_in_envelope::<i16, D>(
7705 <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
7706 encoder, offset + 8, _depth
7707 )
7708 }
7709 DataElement::Int32(ref val) => {
7710 fidl::encoding::encode_in_envelope::<i32, D>(
7711 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
7712 encoder, offset + 8, _depth
7713 )
7714 }
7715 DataElement::Int64(ref val) => {
7716 fidl::encoding::encode_in_envelope::<i64, D>(
7717 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
7718 encoder, offset + 8, _depth
7719 )
7720 }
7721 DataElement::Uint8(ref val) => {
7722 fidl::encoding::encode_in_envelope::<u8, D>(
7723 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
7724 encoder, offset + 8, _depth
7725 )
7726 }
7727 DataElement::Uint16(ref val) => {
7728 fidl::encoding::encode_in_envelope::<u16, D>(
7729 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
7730 encoder, offset + 8, _depth
7731 )
7732 }
7733 DataElement::Uint32(ref val) => {
7734 fidl::encoding::encode_in_envelope::<u32, D>(
7735 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
7736 encoder, offset + 8, _depth
7737 )
7738 }
7739 DataElement::Uint64(ref val) => {
7740 fidl::encoding::encode_in_envelope::<u64, D>(
7741 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
7742 encoder, offset + 8, _depth
7743 )
7744 }
7745 DataElement::Str(ref val) => {
7746 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 1024>, D>(
7747 <fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
7748 encoder, offset + 8, _depth
7749 )
7750 }
7751 DataElement::Url(ref val) => {
7752 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4096>, D>(
7753 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(val),
7754 encoder, offset + 8, _depth
7755 )
7756 }
7757 DataElement::Uuid(ref val) => {
7758 fidl::encoding::encode_in_envelope::<fidl_fuchsia_bluetooth__common::Uuid, D>(
7759 <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(val),
7760 encoder, offset + 8, _depth
7761 )
7762 }
7763 DataElement::B(ref val) => {
7764 fidl::encoding::encode_in_envelope::<bool, D>(
7765 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
7766 encoder, offset + 8, _depth
7767 )
7768 }
7769 DataElement::Sequence(ref val) => {
7770 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>, D>(
7771 <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
7772 encoder, offset + 8, _depth
7773 )
7774 }
7775 DataElement::Alternatives(ref val) => {
7776 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>, D>(
7777 <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
7778 encoder, offset + 8, _depth
7779 )
7780 }
7781 DataElement::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7782 }
7783 }
7784 }
7785
7786 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataElement {
7787 #[inline(always)]
7788 fn new_empty() -> Self {
7789 Self::__SourceBreaking { unknown_ordinal: 0 }
7790 }
7791
7792 #[inline]
7793 unsafe fn decode(
7794 &mut self,
7795 decoder: &mut fidl::encoding::Decoder<'_, D>,
7796 offset: usize,
7797 mut depth: fidl::encoding::Depth,
7798 ) -> fidl::Result<()> {
7799 decoder.debug_check_bounds::<Self>(offset);
7800 #[allow(unused_variables)]
7801 let next_out_of_line = decoder.next_out_of_line();
7802 let handles_before = decoder.remaining_handles();
7803 let (ordinal, inlined, num_bytes, num_handles) =
7804 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7805
7806 let member_inline_size = match ordinal {
7807 1 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7808 2 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7809 3 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7810 4 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7811 5 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7812 6 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7813 7 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7814 8 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7815 9 => <fidl::encoding::Vector<u8, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7816 10 => <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7817 11 => <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7818 12 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7819 13 => <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7820 14 => <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7821 0 => return Err(fidl::Error::UnknownUnionTag),
7822 _ => num_bytes as usize,
7823 };
7824
7825 if inlined != (member_inline_size <= 4) {
7826 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7827 }
7828 let _inner_offset;
7829 if inlined {
7830 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7831 _inner_offset = offset + 8;
7832 } else {
7833 depth.increment()?;
7834 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7835 }
7836 match ordinal {
7837 1 => {
7838 #[allow(irrefutable_let_patterns)]
7839 if let DataElement::Int8(_) = self {
7840 } else {
7842 *self = DataElement::Int8(fidl::new_empty!(i8, D));
7844 }
7845 #[allow(irrefutable_let_patterns)]
7846 if let DataElement::Int8(ref mut val) = self {
7847 fidl::decode!(i8, D, val, decoder, _inner_offset, depth)?;
7848 } else {
7849 unreachable!()
7850 }
7851 }
7852 2 => {
7853 #[allow(irrefutable_let_patterns)]
7854 if let DataElement::Int16(_) = self {
7855 } else {
7857 *self = DataElement::Int16(fidl::new_empty!(i16, D));
7859 }
7860 #[allow(irrefutable_let_patterns)]
7861 if let DataElement::Int16(ref mut val) = self {
7862 fidl::decode!(i16, D, val, decoder, _inner_offset, depth)?;
7863 } else {
7864 unreachable!()
7865 }
7866 }
7867 3 => {
7868 #[allow(irrefutable_let_patterns)]
7869 if let DataElement::Int32(_) = self {
7870 } else {
7872 *self = DataElement::Int32(fidl::new_empty!(i32, D));
7874 }
7875 #[allow(irrefutable_let_patterns)]
7876 if let DataElement::Int32(ref mut val) = self {
7877 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
7878 } else {
7879 unreachable!()
7880 }
7881 }
7882 4 => {
7883 #[allow(irrefutable_let_patterns)]
7884 if let DataElement::Int64(_) = self {
7885 } else {
7887 *self = DataElement::Int64(fidl::new_empty!(i64, D));
7889 }
7890 #[allow(irrefutable_let_patterns)]
7891 if let DataElement::Int64(ref mut val) = self {
7892 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
7893 } else {
7894 unreachable!()
7895 }
7896 }
7897 5 => {
7898 #[allow(irrefutable_let_patterns)]
7899 if let DataElement::Uint8(_) = self {
7900 } else {
7902 *self = DataElement::Uint8(fidl::new_empty!(u8, D));
7904 }
7905 #[allow(irrefutable_let_patterns)]
7906 if let DataElement::Uint8(ref mut val) = self {
7907 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
7908 } else {
7909 unreachable!()
7910 }
7911 }
7912 6 => {
7913 #[allow(irrefutable_let_patterns)]
7914 if let DataElement::Uint16(_) = self {
7915 } else {
7917 *self = DataElement::Uint16(fidl::new_empty!(u16, D));
7919 }
7920 #[allow(irrefutable_let_patterns)]
7921 if let DataElement::Uint16(ref mut val) = self {
7922 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
7923 } else {
7924 unreachable!()
7925 }
7926 }
7927 7 => {
7928 #[allow(irrefutable_let_patterns)]
7929 if let DataElement::Uint32(_) = self {
7930 } else {
7932 *self = DataElement::Uint32(fidl::new_empty!(u32, D));
7934 }
7935 #[allow(irrefutable_let_patterns)]
7936 if let DataElement::Uint32(ref mut val) = self {
7937 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
7938 } else {
7939 unreachable!()
7940 }
7941 }
7942 8 => {
7943 #[allow(irrefutable_let_patterns)]
7944 if let DataElement::Uint64(_) = self {
7945 } else {
7947 *self = DataElement::Uint64(fidl::new_empty!(u64, D));
7949 }
7950 #[allow(irrefutable_let_patterns)]
7951 if let DataElement::Uint64(ref mut val) = self {
7952 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
7953 } else {
7954 unreachable!()
7955 }
7956 }
7957 9 => {
7958 #[allow(irrefutable_let_patterns)]
7959 if let DataElement::Str(_) = self {
7960 } else {
7962 *self =
7964 DataElement::Str(fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D));
7965 }
7966 #[allow(irrefutable_let_patterns)]
7967 if let DataElement::Str(ref mut val) = self {
7968 fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, val, decoder, _inner_offset, depth)?;
7969 } else {
7970 unreachable!()
7971 }
7972 }
7973 10 => {
7974 #[allow(irrefutable_let_patterns)]
7975 if let DataElement::Url(_) = self {
7976 } else {
7978 *self = DataElement::Url(fidl::new_empty!(
7980 fidl::encoding::BoundedString<4096>,
7981 D
7982 ));
7983 }
7984 #[allow(irrefutable_let_patterns)]
7985 if let DataElement::Url(ref mut val) = self {
7986 fidl::decode!(
7987 fidl::encoding::BoundedString<4096>,
7988 D,
7989 val,
7990 decoder,
7991 _inner_offset,
7992 depth
7993 )?;
7994 } else {
7995 unreachable!()
7996 }
7997 }
7998 11 => {
7999 #[allow(irrefutable_let_patterns)]
8000 if let DataElement::Uuid(_) = self {
8001 } else {
8003 *self = DataElement::Uuid(fidl::new_empty!(
8005 fidl_fuchsia_bluetooth__common::Uuid,
8006 D
8007 ));
8008 }
8009 #[allow(irrefutable_let_patterns)]
8010 if let DataElement::Uuid(ref mut val) = self {
8011 fidl::decode!(
8012 fidl_fuchsia_bluetooth__common::Uuid,
8013 D,
8014 val,
8015 decoder,
8016 _inner_offset,
8017 depth
8018 )?;
8019 } else {
8020 unreachable!()
8021 }
8022 }
8023 12 => {
8024 #[allow(irrefutable_let_patterns)]
8025 if let DataElement::B(_) = self {
8026 } else {
8028 *self = DataElement::B(fidl::new_empty!(bool, D));
8030 }
8031 #[allow(irrefutable_let_patterns)]
8032 if let DataElement::B(ref mut val) = self {
8033 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
8034 } else {
8035 unreachable!()
8036 }
8037 }
8038 13 => {
8039 #[allow(irrefutable_let_patterns)]
8040 if let DataElement::Sequence(_) = self {
8041 } else {
8043 *self = DataElement::Sequence(fidl::new_empty!(
8045 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8046 D
8047 ));
8048 }
8049 #[allow(irrefutable_let_patterns)]
8050 if let DataElement::Sequence(ref mut val) = self {
8051 fidl::decode!(
8052 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8053 D,
8054 val,
8055 decoder,
8056 _inner_offset,
8057 depth
8058 )?;
8059 } else {
8060 unreachable!()
8061 }
8062 }
8063 14 => {
8064 #[allow(irrefutable_let_patterns)]
8065 if let DataElement::Alternatives(_) = self {
8066 } else {
8068 *self = DataElement::Alternatives(fidl::new_empty!(
8070 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8071 D
8072 ));
8073 }
8074 #[allow(irrefutable_let_patterns)]
8075 if let DataElement::Alternatives(ref mut val) = self {
8076 fidl::decode!(
8077 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8078 D,
8079 val,
8080 decoder,
8081 _inner_offset,
8082 depth
8083 )?;
8084 } else {
8085 unreachable!()
8086 }
8087 }
8088 #[allow(deprecated)]
8089 ordinal => {
8090 for _ in 0..num_handles {
8091 decoder.drop_next_handle()?;
8092 }
8093 *self = DataElement::__SourceBreaking { unknown_ordinal: ordinal };
8094 }
8095 }
8096 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8097 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8098 }
8099 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8100 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8101 }
8102 Ok(())
8103 }
8104 }
8105
8106 impl fidl::encoding::ValueTypeMarker for ScoConnectionOnConnectionCompleteRequest {
8107 type Borrowed<'a> = &'a Self;
8108 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8109 value
8110 }
8111 }
8112
8113 unsafe impl fidl::encoding::TypeMarker for ScoConnectionOnConnectionCompleteRequest {
8114 type Owned = Self;
8115
8116 #[inline(always)]
8117 fn inline_align(_context: fidl::encoding::Context) -> usize {
8118 8
8119 }
8120
8121 #[inline(always)]
8122 fn inline_size(_context: fidl::encoding::Context) -> usize {
8123 16
8124 }
8125 }
8126
8127 unsafe impl<D: fidl::encoding::ResourceDialect>
8128 fidl::encoding::Encode<ScoConnectionOnConnectionCompleteRequest, D>
8129 for &ScoConnectionOnConnectionCompleteRequest
8130 {
8131 #[inline]
8132 unsafe fn encode(
8133 self,
8134 encoder: &mut fidl::encoding::Encoder<'_, D>,
8135 offset: usize,
8136 _depth: fidl::encoding::Depth,
8137 ) -> fidl::Result<()> {
8138 encoder.debug_check_bounds::<ScoConnectionOnConnectionCompleteRequest>(offset);
8139 encoder.write_num::<u64>(self.ordinal(), offset);
8140 match self {
8141 ScoConnectionOnConnectionCompleteRequest::ConnectedParams(ref val) => {
8142 fidl::encoding::encode_in_envelope::<ScoConnectionParameters, D>(
8143 <ScoConnectionParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
8144 encoder,
8145 offset + 8,
8146 _depth,
8147 )
8148 }
8149 ScoConnectionOnConnectionCompleteRequest::Error(ref val) => {
8150 fidl::encoding::encode_in_envelope::<ScoErrorCode, D>(
8151 <ScoErrorCode as fidl::encoding::ValueTypeMarker>::borrow(val),
8152 encoder,
8153 offset + 8,
8154 _depth,
8155 )
8156 }
8157 ScoConnectionOnConnectionCompleteRequest::__SourceBreaking { .. } => {
8158 Err(fidl::Error::UnknownUnionTag)
8159 }
8160 }
8161 }
8162 }
8163
8164 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8165 for ScoConnectionOnConnectionCompleteRequest
8166 {
8167 #[inline(always)]
8168 fn new_empty() -> Self {
8169 Self::__SourceBreaking { unknown_ordinal: 0 }
8170 }
8171
8172 #[inline]
8173 unsafe fn decode(
8174 &mut self,
8175 decoder: &mut fidl::encoding::Decoder<'_, D>,
8176 offset: usize,
8177 mut depth: fidl::encoding::Depth,
8178 ) -> fidl::Result<()> {
8179 decoder.debug_check_bounds::<Self>(offset);
8180 #[allow(unused_variables)]
8181 let next_out_of_line = decoder.next_out_of_line();
8182 let handles_before = decoder.remaining_handles();
8183 let (ordinal, inlined, num_bytes, num_handles) =
8184 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
8185
8186 let member_inline_size = match ordinal {
8187 1 => <ScoConnectionParameters as fidl::encoding::TypeMarker>::inline_size(
8188 decoder.context,
8189 ),
8190 2 => <ScoErrorCode as fidl::encoding::TypeMarker>::inline_size(decoder.context),
8191 0 => return Err(fidl::Error::UnknownUnionTag),
8192 _ => num_bytes as usize,
8193 };
8194
8195 if inlined != (member_inline_size <= 4) {
8196 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8197 }
8198 let _inner_offset;
8199 if inlined {
8200 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
8201 _inner_offset = offset + 8;
8202 } else {
8203 depth.increment()?;
8204 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8205 }
8206 match ordinal {
8207 1 => {
8208 #[allow(irrefutable_let_patterns)]
8209 if let ScoConnectionOnConnectionCompleteRequest::ConnectedParams(_) = self {
8210 } else {
8212 *self = ScoConnectionOnConnectionCompleteRequest::ConnectedParams(
8214 fidl::new_empty!(ScoConnectionParameters, D),
8215 );
8216 }
8217 #[allow(irrefutable_let_patterns)]
8218 if let ScoConnectionOnConnectionCompleteRequest::ConnectedParams(ref mut val) =
8219 self
8220 {
8221 fidl::decode!(
8222 ScoConnectionParameters,
8223 D,
8224 val,
8225 decoder,
8226 _inner_offset,
8227 depth
8228 )?;
8229 } else {
8230 unreachable!()
8231 }
8232 }
8233 2 => {
8234 #[allow(irrefutable_let_patterns)]
8235 if let ScoConnectionOnConnectionCompleteRequest::Error(_) = self {
8236 } else {
8238 *self = ScoConnectionOnConnectionCompleteRequest::Error(fidl::new_empty!(
8240 ScoErrorCode,
8241 D
8242 ));
8243 }
8244 #[allow(irrefutable_let_patterns)]
8245 if let ScoConnectionOnConnectionCompleteRequest::Error(ref mut val) = self {
8246 fidl::decode!(ScoErrorCode, D, val, decoder, _inner_offset, depth)?;
8247 } else {
8248 unreachable!()
8249 }
8250 }
8251 #[allow(deprecated)]
8252 ordinal => {
8253 for _ in 0..num_handles {
8254 decoder.drop_next_handle()?;
8255 }
8256 *self = ScoConnectionOnConnectionCompleteRequest::__SourceBreaking {
8257 unknown_ordinal: ordinal,
8258 };
8259 }
8260 }
8261 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8262 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8263 }
8264 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8265 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8266 }
8267 Ok(())
8268 }
8269 }
8270}