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
1441pub mod audio_direction_ext_ordinals {
1442 pub const SET_PRIORITY: u64 = 0x792713ef3b2bc38a;
1443}
1444
1445pub mod audio_offload_controller_ordinals {
1446 pub const ON_STARTED: u64 = 0x7b624f210570fc30;
1447 pub const STOP: u64 = 0x37845d5a47ce5e39;
1448}
1449
1450pub mod audio_offload_ext_ordinals {
1451 pub const GET_SUPPORTED_FEATURES: u64 = 0x44ab0b88dde41f94;
1452 pub const START_AUDIO_OFFLOAD: u64 = 0x2172ac626202c1c9;
1453}
1454
1455pub mod connection_receiver_ordinals {
1456 pub const CONNECTED: u64 = 0xa5251eebbccf928;
1457 pub const ON_REVOKE: u64 = 0x9b35c093a0468d1;
1458}
1459
1460pub mod connection_receiver2_ordinals {
1461 pub const CONNECTED: u64 = 0x602c15a8004564de;
1462 pub const ON_REVOKE: u64 = 0x11281753d1e1851c;
1463}
1464
1465pub mod l2cap_parameters_ext_ordinals {
1466 pub const REQUEST_PARAMETERS: u64 = 0x1da4d8f268e2e918;
1467}
1468
1469pub mod profile_ordinals {
1470 pub const ADVERTISE: u64 = 0x65e429c1f0205a0e;
1471 pub const SEARCH: u64 = 0x2c59d8580bc8ef0a;
1472 pub const CONNECT: u64 = 0xaaeefc898901fb3;
1473 pub const CONNECT_SCO: u64 = 0x961976ddd116ee6;
1474}
1475
1476pub mod sco_connection_ordinals {
1477 pub const READ: u64 = 0x6fb29eb1e16ac616;
1478 pub const WRITE: u64 = 0x394e1b2ff7f4a5a9;
1479 pub const ON_CONNECTION_COMPLETE: u64 = 0x193aa06408ba384d;
1480}
1481
1482pub mod search_results_ordinals {
1483 pub const SERVICE_FOUND: u64 = 0x526509a842ebd43c;
1484}
1485
1486mod internal {
1487 use super::*;
1488 unsafe impl fidl::encoding::TypeMarker for A2dpDirectionPriority {
1489 type Owned = Self;
1490
1491 #[inline(always)]
1492 fn inline_align(_context: fidl::encoding::Context) -> usize {
1493 std::mem::align_of::<u32>()
1494 }
1495
1496 #[inline(always)]
1497 fn inline_size(_context: fidl::encoding::Context) -> usize {
1498 std::mem::size_of::<u32>()
1499 }
1500
1501 #[inline(always)]
1502 fn encode_is_copy() -> bool {
1503 true
1504 }
1505
1506 #[inline(always)]
1507 fn decode_is_copy() -> bool {
1508 false
1509 }
1510 }
1511
1512 impl fidl::encoding::ValueTypeMarker for A2dpDirectionPriority {
1513 type Borrowed<'a> = Self;
1514 #[inline(always)]
1515 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1516 *value
1517 }
1518 }
1519
1520 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1521 for A2dpDirectionPriority
1522 {
1523 #[inline]
1524 unsafe fn encode(
1525 self,
1526 encoder: &mut fidl::encoding::Encoder<'_, D>,
1527 offset: usize,
1528 _depth: fidl::encoding::Depth,
1529 ) -> fidl::Result<()> {
1530 encoder.debug_check_bounds::<Self>(offset);
1531 encoder.write_num(self.into_primitive(), offset);
1532 Ok(())
1533 }
1534 }
1535
1536 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for A2dpDirectionPriority {
1537 #[inline(always)]
1538 fn new_empty() -> Self {
1539 Self::Normal
1540 }
1541
1542 #[inline]
1543 unsafe fn decode(
1544 &mut self,
1545 decoder: &mut fidl::encoding::Decoder<'_, D>,
1546 offset: usize,
1547 _depth: fidl::encoding::Depth,
1548 ) -> fidl::Result<()> {
1549 decoder.debug_check_bounds::<Self>(offset);
1550 let prim = decoder.read_num::<u32>(offset);
1551
1552 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1553 Ok(())
1554 }
1555 }
1556 unsafe impl fidl::encoding::TypeMarker for AudioBitsPerSample {
1557 type Owned = Self;
1558
1559 #[inline(always)]
1560 fn inline_align(_context: fidl::encoding::Context) -> usize {
1561 std::mem::align_of::<u8>()
1562 }
1563
1564 #[inline(always)]
1565 fn inline_size(_context: fidl::encoding::Context) -> usize {
1566 std::mem::size_of::<u8>()
1567 }
1568
1569 #[inline(always)]
1570 fn encode_is_copy() -> bool {
1571 false
1572 }
1573
1574 #[inline(always)]
1575 fn decode_is_copy() -> bool {
1576 false
1577 }
1578 }
1579
1580 impl fidl::encoding::ValueTypeMarker for AudioBitsPerSample {
1581 type Borrowed<'a> = Self;
1582 #[inline(always)]
1583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1584 *value
1585 }
1586 }
1587
1588 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1589 for AudioBitsPerSample
1590 {
1591 #[inline]
1592 unsafe fn encode(
1593 self,
1594 encoder: &mut fidl::encoding::Encoder<'_, D>,
1595 offset: usize,
1596 _depth: fidl::encoding::Depth,
1597 ) -> fidl::Result<()> {
1598 encoder.debug_check_bounds::<Self>(offset);
1599 encoder.write_num(self.into_primitive(), offset);
1600 Ok(())
1601 }
1602 }
1603
1604 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioBitsPerSample {
1605 #[inline(always)]
1606 fn new_empty() -> Self {
1607 Self::unknown()
1608 }
1609
1610 #[inline]
1611 unsafe fn decode(
1612 &mut self,
1613 decoder: &mut fidl::encoding::Decoder<'_, D>,
1614 offset: usize,
1615 _depth: fidl::encoding::Depth,
1616 ) -> fidl::Result<()> {
1617 decoder.debug_check_bounds::<Self>(offset);
1618 let prim = decoder.read_num::<u8>(offset);
1619
1620 *self = Self::from_primitive_allow_unknown(prim);
1621 Ok(())
1622 }
1623 }
1624 unsafe impl fidl::encoding::TypeMarker for AudioChannelMode {
1625 type Owned = Self;
1626
1627 #[inline(always)]
1628 fn inline_align(_context: fidl::encoding::Context) -> usize {
1629 std::mem::align_of::<u8>()
1630 }
1631
1632 #[inline(always)]
1633 fn inline_size(_context: fidl::encoding::Context) -> usize {
1634 std::mem::size_of::<u8>()
1635 }
1636
1637 #[inline(always)]
1638 fn encode_is_copy() -> bool {
1639 false
1640 }
1641
1642 #[inline(always)]
1643 fn decode_is_copy() -> bool {
1644 false
1645 }
1646 }
1647
1648 impl fidl::encoding::ValueTypeMarker for AudioChannelMode {
1649 type Borrowed<'a> = Self;
1650 #[inline(always)]
1651 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1652 *value
1653 }
1654 }
1655
1656 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1657 for AudioChannelMode
1658 {
1659 #[inline]
1660 unsafe fn encode(
1661 self,
1662 encoder: &mut fidl::encoding::Encoder<'_, D>,
1663 offset: usize,
1664 _depth: fidl::encoding::Depth,
1665 ) -> fidl::Result<()> {
1666 encoder.debug_check_bounds::<Self>(offset);
1667 encoder.write_num(self.into_primitive(), offset);
1668 Ok(())
1669 }
1670 }
1671
1672 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioChannelMode {
1673 #[inline(always)]
1674 fn new_empty() -> Self {
1675 Self::unknown()
1676 }
1677
1678 #[inline]
1679 unsafe fn decode(
1680 &mut self,
1681 decoder: &mut fidl::encoding::Decoder<'_, D>,
1682 offset: usize,
1683 _depth: fidl::encoding::Depth,
1684 ) -> fidl::Result<()> {
1685 decoder.debug_check_bounds::<Self>(offset);
1686 let prim = decoder.read_num::<u8>(offset);
1687
1688 *self = Self::from_primitive_allow_unknown(prim);
1689 Ok(())
1690 }
1691 }
1692 unsafe impl fidl::encoding::TypeMarker for AudioSamplingFrequency {
1693 type Owned = Self;
1694
1695 #[inline(always)]
1696 fn inline_align(_context: fidl::encoding::Context) -> usize {
1697 std::mem::align_of::<u8>()
1698 }
1699
1700 #[inline(always)]
1701 fn inline_size(_context: fidl::encoding::Context) -> usize {
1702 std::mem::size_of::<u8>()
1703 }
1704
1705 #[inline(always)]
1706 fn encode_is_copy() -> bool {
1707 false
1708 }
1709
1710 #[inline(always)]
1711 fn decode_is_copy() -> bool {
1712 false
1713 }
1714 }
1715
1716 impl fidl::encoding::ValueTypeMarker for AudioSamplingFrequency {
1717 type Borrowed<'a> = Self;
1718 #[inline(always)]
1719 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1720 *value
1721 }
1722 }
1723
1724 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1725 for AudioSamplingFrequency
1726 {
1727 #[inline]
1728 unsafe fn encode(
1729 self,
1730 encoder: &mut fidl::encoding::Encoder<'_, D>,
1731 offset: usize,
1732 _depth: fidl::encoding::Depth,
1733 ) -> fidl::Result<()> {
1734 encoder.debug_check_bounds::<Self>(offset);
1735 encoder.write_num(self.into_primitive(), offset);
1736 Ok(())
1737 }
1738 }
1739
1740 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1741 for AudioSamplingFrequency
1742 {
1743 #[inline(always)]
1744 fn new_empty() -> Self {
1745 Self::unknown()
1746 }
1747
1748 #[inline]
1749 unsafe fn decode(
1750 &mut self,
1751 decoder: &mut fidl::encoding::Decoder<'_, D>,
1752 offset: usize,
1753 _depth: fidl::encoding::Depth,
1754 ) -> fidl::Result<()> {
1755 decoder.debug_check_bounds::<Self>(offset);
1756 let prim = decoder.read_num::<u8>(offset);
1757
1758 *self = Self::from_primitive_allow_unknown(prim);
1759 Ok(())
1760 }
1761 }
1762 unsafe impl fidl::encoding::TypeMarker for DataPath {
1763 type Owned = Self;
1764
1765 #[inline(always)]
1766 fn inline_align(_context: fidl::encoding::Context) -> usize {
1767 std::mem::align_of::<u8>()
1768 }
1769
1770 #[inline(always)]
1771 fn inline_size(_context: fidl::encoding::Context) -> usize {
1772 std::mem::size_of::<u8>()
1773 }
1774
1775 #[inline(always)]
1776 fn encode_is_copy() -> bool {
1777 true
1778 }
1779
1780 #[inline(always)]
1781 fn decode_is_copy() -> bool {
1782 false
1783 }
1784 }
1785
1786 impl fidl::encoding::ValueTypeMarker for DataPath {
1787 type Borrowed<'a> = Self;
1788 #[inline(always)]
1789 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1790 *value
1791 }
1792 }
1793
1794 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DataPath {
1795 #[inline]
1796 unsafe fn encode(
1797 self,
1798 encoder: &mut fidl::encoding::Encoder<'_, D>,
1799 offset: usize,
1800 _depth: fidl::encoding::Depth,
1801 ) -> fidl::Result<()> {
1802 encoder.debug_check_bounds::<Self>(offset);
1803 encoder.write_num(self.into_primitive(), offset);
1804 Ok(())
1805 }
1806 }
1807
1808 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataPath {
1809 #[inline(always)]
1810 fn new_empty() -> Self {
1811 Self::Host
1812 }
1813
1814 #[inline]
1815 unsafe fn decode(
1816 &mut self,
1817 decoder: &mut fidl::encoding::Decoder<'_, D>,
1818 offset: usize,
1819 _depth: fidl::encoding::Depth,
1820 ) -> fidl::Result<()> {
1821 decoder.debug_check_bounds::<Self>(offset);
1822 let prim = decoder.read_num::<u8>(offset);
1823
1824 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1825 Ok(())
1826 }
1827 }
1828 unsafe impl fidl::encoding::TypeMarker for HfpParameterSet {
1829 type Owned = Self;
1830
1831 #[inline(always)]
1832 fn inline_align(_context: fidl::encoding::Context) -> usize {
1833 std::mem::align_of::<u8>()
1834 }
1835
1836 #[inline(always)]
1837 fn inline_size(_context: fidl::encoding::Context) -> usize {
1838 std::mem::size_of::<u8>()
1839 }
1840
1841 #[inline(always)]
1842 fn encode_is_copy() -> bool {
1843 false
1844 }
1845
1846 #[inline(always)]
1847 fn decode_is_copy() -> bool {
1848 false
1849 }
1850 }
1851
1852 impl fidl::encoding::ValueTypeMarker for HfpParameterSet {
1853 type Borrowed<'a> = Self;
1854 #[inline(always)]
1855 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1856 *value
1857 }
1858 }
1859
1860 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1861 for HfpParameterSet
1862 {
1863 #[inline]
1864 unsafe fn encode(
1865 self,
1866 encoder: &mut fidl::encoding::Encoder<'_, D>,
1867 offset: usize,
1868 _depth: fidl::encoding::Depth,
1869 ) -> fidl::Result<()> {
1870 encoder.debug_check_bounds::<Self>(offset);
1871 encoder.write_num(self.into_primitive(), offset);
1872 Ok(())
1873 }
1874 }
1875
1876 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HfpParameterSet {
1877 #[inline(always)]
1878 fn new_empty() -> Self {
1879 Self::unknown()
1880 }
1881
1882 #[inline]
1883 unsafe fn decode(
1884 &mut self,
1885 decoder: &mut fidl::encoding::Decoder<'_, D>,
1886 offset: usize,
1887 _depth: fidl::encoding::Depth,
1888 ) -> fidl::Result<()> {
1889 decoder.debug_check_bounds::<Self>(offset);
1890 let prim = decoder.read_num::<u8>(offset);
1891
1892 *self = Self::from_primitive_allow_unknown(prim);
1893 Ok(())
1894 }
1895 }
1896 unsafe impl fidl::encoding::TypeMarker for ProtocolIdentifier {
1897 type Owned = Self;
1898
1899 #[inline(always)]
1900 fn inline_align(_context: fidl::encoding::Context) -> usize {
1901 std::mem::align_of::<u16>()
1902 }
1903
1904 #[inline(always)]
1905 fn inline_size(_context: fidl::encoding::Context) -> usize {
1906 std::mem::size_of::<u16>()
1907 }
1908
1909 #[inline(always)]
1910 fn encode_is_copy() -> bool {
1911 false
1912 }
1913
1914 #[inline(always)]
1915 fn decode_is_copy() -> bool {
1916 false
1917 }
1918 }
1919
1920 impl fidl::encoding::ValueTypeMarker for ProtocolIdentifier {
1921 type Borrowed<'a> = Self;
1922 #[inline(always)]
1923 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1924 *value
1925 }
1926 }
1927
1928 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1929 for ProtocolIdentifier
1930 {
1931 #[inline]
1932 unsafe fn encode(
1933 self,
1934 encoder: &mut fidl::encoding::Encoder<'_, D>,
1935 offset: usize,
1936 _depth: fidl::encoding::Depth,
1937 ) -> fidl::Result<()> {
1938 encoder.debug_check_bounds::<Self>(offset);
1939 encoder.write_num(self.into_primitive(), offset);
1940 Ok(())
1941 }
1942 }
1943
1944 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolIdentifier {
1945 #[inline(always)]
1946 fn new_empty() -> Self {
1947 Self::unknown()
1948 }
1949
1950 #[inline]
1951 unsafe fn decode(
1952 &mut self,
1953 decoder: &mut fidl::encoding::Decoder<'_, D>,
1954 offset: usize,
1955 _depth: fidl::encoding::Depth,
1956 ) -> fidl::Result<()> {
1957 decoder.debug_check_bounds::<Self>(offset);
1958 let prim = decoder.read_num::<u16>(offset);
1959
1960 *self = Self::from_primitive_allow_unknown(prim);
1961 Ok(())
1962 }
1963 }
1964 unsafe impl fidl::encoding::TypeMarker for RxPacketStatus {
1965 type Owned = Self;
1966
1967 #[inline(always)]
1968 fn inline_align(_context: fidl::encoding::Context) -> usize {
1969 std::mem::align_of::<u8>()
1970 }
1971
1972 #[inline(always)]
1973 fn inline_size(_context: fidl::encoding::Context) -> usize {
1974 std::mem::size_of::<u8>()
1975 }
1976
1977 #[inline(always)]
1978 fn encode_is_copy() -> bool {
1979 true
1980 }
1981
1982 #[inline(always)]
1983 fn decode_is_copy() -> bool {
1984 false
1985 }
1986 }
1987
1988 impl fidl::encoding::ValueTypeMarker for RxPacketStatus {
1989 type Borrowed<'a> = Self;
1990 #[inline(always)]
1991 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1992 *value
1993 }
1994 }
1995
1996 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for RxPacketStatus {
1997 #[inline]
1998 unsafe fn encode(
1999 self,
2000 encoder: &mut fidl::encoding::Encoder<'_, D>,
2001 offset: usize,
2002 _depth: fidl::encoding::Depth,
2003 ) -> fidl::Result<()> {
2004 encoder.debug_check_bounds::<Self>(offset);
2005 encoder.write_num(self.into_primitive(), offset);
2006 Ok(())
2007 }
2008 }
2009
2010 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RxPacketStatus {
2011 #[inline(always)]
2012 fn new_empty() -> Self {
2013 Self::CorrectlyReceivedData
2014 }
2015
2016 #[inline]
2017 unsafe fn decode(
2018 &mut self,
2019 decoder: &mut fidl::encoding::Decoder<'_, D>,
2020 offset: usize,
2021 _depth: fidl::encoding::Depth,
2022 ) -> fidl::Result<()> {
2023 decoder.debug_check_bounds::<Self>(offset);
2024 let prim = decoder.read_num::<u8>(offset);
2025
2026 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2027 Ok(())
2028 }
2029 }
2030 unsafe impl fidl::encoding::TypeMarker for ScoErrorCode {
2031 type Owned = Self;
2032
2033 #[inline(always)]
2034 fn inline_align(_context: fidl::encoding::Context) -> usize {
2035 std::mem::align_of::<u32>()
2036 }
2037
2038 #[inline(always)]
2039 fn inline_size(_context: fidl::encoding::Context) -> usize {
2040 std::mem::size_of::<u32>()
2041 }
2042
2043 #[inline(always)]
2044 fn encode_is_copy() -> bool {
2045 false
2046 }
2047
2048 #[inline(always)]
2049 fn decode_is_copy() -> bool {
2050 false
2051 }
2052 }
2053
2054 impl fidl::encoding::ValueTypeMarker for ScoErrorCode {
2055 type Borrowed<'a> = Self;
2056 #[inline(always)]
2057 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2058 *value
2059 }
2060 }
2061
2062 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScoErrorCode {
2063 #[inline]
2064 unsafe fn encode(
2065 self,
2066 encoder: &mut fidl::encoding::Encoder<'_, D>,
2067 offset: usize,
2068 _depth: fidl::encoding::Depth,
2069 ) -> fidl::Result<()> {
2070 encoder.debug_check_bounds::<Self>(offset);
2071 encoder.write_num(self.into_primitive(), offset);
2072 Ok(())
2073 }
2074 }
2075
2076 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScoErrorCode {
2077 #[inline(always)]
2078 fn new_empty() -> Self {
2079 Self::unknown()
2080 }
2081
2082 #[inline]
2083 unsafe fn decode(
2084 &mut self,
2085 decoder: &mut fidl::encoding::Decoder<'_, D>,
2086 offset: usize,
2087 _depth: fidl::encoding::Depth,
2088 ) -> fidl::Result<()> {
2089 decoder.debug_check_bounds::<Self>(offset);
2090 let prim = decoder.read_num::<u32>(offset);
2091
2092 *self = Self::from_primitive_allow_unknown(prim);
2093 Ok(())
2094 }
2095 }
2096 unsafe impl fidl::encoding::TypeMarker for ServiceClassProfileIdentifier {
2097 type Owned = Self;
2098
2099 #[inline(always)]
2100 fn inline_align(_context: fidl::encoding::Context) -> usize {
2101 std::mem::align_of::<u16>()
2102 }
2103
2104 #[inline(always)]
2105 fn inline_size(_context: fidl::encoding::Context) -> usize {
2106 std::mem::size_of::<u16>()
2107 }
2108
2109 #[inline(always)]
2110 fn encode_is_copy() -> bool {
2111 false
2112 }
2113
2114 #[inline(always)]
2115 fn decode_is_copy() -> bool {
2116 false
2117 }
2118 }
2119
2120 impl fidl::encoding::ValueTypeMarker for ServiceClassProfileIdentifier {
2121 type Borrowed<'a> = Self;
2122 #[inline(always)]
2123 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2124 *value
2125 }
2126 }
2127
2128 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2129 for ServiceClassProfileIdentifier
2130 {
2131 #[inline]
2132 unsafe fn encode(
2133 self,
2134 encoder: &mut fidl::encoding::Encoder<'_, D>,
2135 offset: usize,
2136 _depth: fidl::encoding::Depth,
2137 ) -> fidl::Result<()> {
2138 encoder.debug_check_bounds::<Self>(offset);
2139 encoder.write_num(self.into_primitive(), offset);
2140 Ok(())
2141 }
2142 }
2143
2144 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2145 for ServiceClassProfileIdentifier
2146 {
2147 #[inline(always)]
2148 fn new_empty() -> Self {
2149 Self::unknown()
2150 }
2151
2152 #[inline]
2153 unsafe fn decode(
2154 &mut self,
2155 decoder: &mut fidl::encoding::Decoder<'_, D>,
2156 offset: usize,
2157 _depth: fidl::encoding::Depth,
2158 ) -> fidl::Result<()> {
2159 decoder.debug_check_bounds::<Self>(offset);
2160 let prim = decoder.read_num::<u16>(offset);
2161
2162 *self = Self::from_primitive_allow_unknown(prim);
2163 Ok(())
2164 }
2165 }
2166
2167 impl fidl::encoding::ValueTypeMarker for AudioDirectionExtSetPriorityRequest {
2168 type Borrowed<'a> = &'a Self;
2169 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2170 value
2171 }
2172 }
2173
2174 unsafe impl fidl::encoding::TypeMarker for AudioDirectionExtSetPriorityRequest {
2175 type Owned = Self;
2176
2177 #[inline(always)]
2178 fn inline_align(_context: fidl::encoding::Context) -> usize {
2179 4
2180 }
2181
2182 #[inline(always)]
2183 fn inline_size(_context: fidl::encoding::Context) -> usize {
2184 4
2185 }
2186 }
2187
2188 unsafe impl<D: fidl::encoding::ResourceDialect>
2189 fidl::encoding::Encode<AudioDirectionExtSetPriorityRequest, D>
2190 for &AudioDirectionExtSetPriorityRequest
2191 {
2192 #[inline]
2193 unsafe fn encode(
2194 self,
2195 encoder: &mut fidl::encoding::Encoder<'_, D>,
2196 offset: usize,
2197 _depth: fidl::encoding::Depth,
2198 ) -> fidl::Result<()> {
2199 encoder.debug_check_bounds::<AudioDirectionExtSetPriorityRequest>(offset);
2200 fidl::encoding::Encode::<AudioDirectionExtSetPriorityRequest, D>::encode(
2202 (<A2dpDirectionPriority as fidl::encoding::ValueTypeMarker>::borrow(
2203 &self.priority,
2204 ),),
2205 encoder,
2206 offset,
2207 _depth,
2208 )
2209 }
2210 }
2211 unsafe impl<
2212 D: fidl::encoding::ResourceDialect,
2213 T0: fidl::encoding::Encode<A2dpDirectionPriority, D>,
2214 > fidl::encoding::Encode<AudioDirectionExtSetPriorityRequest, D> for (T0,)
2215 {
2216 #[inline]
2217 unsafe fn encode(
2218 self,
2219 encoder: &mut fidl::encoding::Encoder<'_, D>,
2220 offset: usize,
2221 depth: fidl::encoding::Depth,
2222 ) -> fidl::Result<()> {
2223 encoder.debug_check_bounds::<AudioDirectionExtSetPriorityRequest>(offset);
2224 self.0.encode(encoder, offset + 0, depth)?;
2228 Ok(())
2229 }
2230 }
2231
2232 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2233 for AudioDirectionExtSetPriorityRequest
2234 {
2235 #[inline(always)]
2236 fn new_empty() -> Self {
2237 Self { priority: fidl::new_empty!(A2dpDirectionPriority, D) }
2238 }
2239
2240 #[inline]
2241 unsafe fn decode(
2242 &mut self,
2243 decoder: &mut fidl::encoding::Decoder<'_, D>,
2244 offset: usize,
2245 _depth: fidl::encoding::Depth,
2246 ) -> fidl::Result<()> {
2247 decoder.debug_check_bounds::<Self>(offset);
2248 fidl::decode!(
2250 A2dpDirectionPriority,
2251 D,
2252 &mut self.priority,
2253 decoder,
2254 offset + 0,
2255 _depth
2256 )?;
2257 Ok(())
2258 }
2259 }
2260
2261 impl fidl::encoding::ValueTypeMarker for L2capParametersExtRequestParametersRequest {
2262 type Borrowed<'a> = &'a Self;
2263 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2264 value
2265 }
2266 }
2267
2268 unsafe impl fidl::encoding::TypeMarker for L2capParametersExtRequestParametersRequest {
2269 type Owned = Self;
2270
2271 #[inline(always)]
2272 fn inline_align(_context: fidl::encoding::Context) -> usize {
2273 8
2274 }
2275
2276 #[inline(always)]
2277 fn inline_size(_context: fidl::encoding::Context) -> usize {
2278 16
2279 }
2280 }
2281
2282 unsafe impl<D: fidl::encoding::ResourceDialect>
2283 fidl::encoding::Encode<L2capParametersExtRequestParametersRequest, D>
2284 for &L2capParametersExtRequestParametersRequest
2285 {
2286 #[inline]
2287 unsafe fn encode(
2288 self,
2289 encoder: &mut fidl::encoding::Encoder<'_, D>,
2290 offset: usize,
2291 _depth: fidl::encoding::Depth,
2292 ) -> fidl::Result<()> {
2293 encoder.debug_check_bounds::<L2capParametersExtRequestParametersRequest>(offset);
2294 fidl::encoding::Encode::<L2capParametersExtRequestParametersRequest, D>::encode(
2296 (
2297 <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.request),
2298 ),
2299 encoder, offset, _depth
2300 )
2301 }
2302 }
2303 unsafe impl<
2304 D: fidl::encoding::ResourceDialect,
2305 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::ChannelParameters, D>,
2306 > fidl::encoding::Encode<L2capParametersExtRequestParametersRequest, D> for (T0,)
2307 {
2308 #[inline]
2309 unsafe fn encode(
2310 self,
2311 encoder: &mut fidl::encoding::Encoder<'_, D>,
2312 offset: usize,
2313 depth: fidl::encoding::Depth,
2314 ) -> fidl::Result<()> {
2315 encoder.debug_check_bounds::<L2capParametersExtRequestParametersRequest>(offset);
2316 self.0.encode(encoder, offset + 0, depth)?;
2320 Ok(())
2321 }
2322 }
2323
2324 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2325 for L2capParametersExtRequestParametersRequest
2326 {
2327 #[inline(always)]
2328 fn new_empty() -> Self {
2329 Self { request: fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D) }
2330 }
2331
2332 #[inline]
2333 unsafe fn decode(
2334 &mut self,
2335 decoder: &mut fidl::encoding::Decoder<'_, D>,
2336 offset: usize,
2337 _depth: fidl::encoding::Depth,
2338 ) -> fidl::Result<()> {
2339 decoder.debug_check_bounds::<Self>(offset);
2340 fidl::decode!(
2342 fidl_fuchsia_bluetooth__common::ChannelParameters,
2343 D,
2344 &mut self.request,
2345 decoder,
2346 offset + 0,
2347 _depth
2348 )?;
2349 Ok(())
2350 }
2351 }
2352
2353 impl fidl::encoding::ValueTypeMarker for L2capParametersExtRequestParametersResponse {
2354 type Borrowed<'a> = &'a Self;
2355 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2356 value
2357 }
2358 }
2359
2360 unsafe impl fidl::encoding::TypeMarker for L2capParametersExtRequestParametersResponse {
2361 type Owned = Self;
2362
2363 #[inline(always)]
2364 fn inline_align(_context: fidl::encoding::Context) -> usize {
2365 8
2366 }
2367
2368 #[inline(always)]
2369 fn inline_size(_context: fidl::encoding::Context) -> usize {
2370 16
2371 }
2372 }
2373
2374 unsafe impl<D: fidl::encoding::ResourceDialect>
2375 fidl::encoding::Encode<L2capParametersExtRequestParametersResponse, D>
2376 for &L2capParametersExtRequestParametersResponse
2377 {
2378 #[inline]
2379 unsafe fn encode(
2380 self,
2381 encoder: &mut fidl::encoding::Encoder<'_, D>,
2382 offset: usize,
2383 _depth: fidl::encoding::Depth,
2384 ) -> fidl::Result<()> {
2385 encoder.debug_check_bounds::<L2capParametersExtRequestParametersResponse>(offset);
2386 fidl::encoding::Encode::<L2capParametersExtRequestParametersResponse, D>::encode(
2388 (
2389 <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.new),
2390 ),
2391 encoder, offset, _depth
2392 )
2393 }
2394 }
2395 unsafe impl<
2396 D: fidl::encoding::ResourceDialect,
2397 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::ChannelParameters, D>,
2398 > fidl::encoding::Encode<L2capParametersExtRequestParametersResponse, D> for (T0,)
2399 {
2400 #[inline]
2401 unsafe fn encode(
2402 self,
2403 encoder: &mut fidl::encoding::Encoder<'_, D>,
2404 offset: usize,
2405 depth: fidl::encoding::Depth,
2406 ) -> fidl::Result<()> {
2407 encoder.debug_check_bounds::<L2capParametersExtRequestParametersResponse>(offset);
2408 self.0.encode(encoder, offset + 0, depth)?;
2412 Ok(())
2413 }
2414 }
2415
2416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2417 for L2capParametersExtRequestParametersResponse
2418 {
2419 #[inline(always)]
2420 fn new_empty() -> Self {
2421 Self { new: fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D) }
2422 }
2423
2424 #[inline]
2425 unsafe fn decode(
2426 &mut self,
2427 decoder: &mut fidl::encoding::Decoder<'_, D>,
2428 offset: usize,
2429 _depth: fidl::encoding::Depth,
2430 ) -> fidl::Result<()> {
2431 decoder.debug_check_bounds::<Self>(offset);
2432 fidl::decode!(
2434 fidl_fuchsia_bluetooth__common::ChannelParameters,
2435 D,
2436 &mut self.new,
2437 decoder,
2438 offset + 0,
2439 _depth
2440 )?;
2441 Ok(())
2442 }
2443 }
2444
2445 impl fidl::encoding::ValueTypeMarker for ProfileConnectRequest {
2446 type Borrowed<'a> = &'a Self;
2447 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2448 value
2449 }
2450 }
2451
2452 unsafe impl fidl::encoding::TypeMarker for ProfileConnectRequest {
2453 type Owned = Self;
2454
2455 #[inline(always)]
2456 fn inline_align(_context: fidl::encoding::Context) -> usize {
2457 8
2458 }
2459
2460 #[inline(always)]
2461 fn inline_size(_context: fidl::encoding::Context) -> usize {
2462 24
2463 }
2464 }
2465
2466 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProfileConnectRequest, D>
2467 for &ProfileConnectRequest
2468 {
2469 #[inline]
2470 unsafe fn encode(
2471 self,
2472 encoder: &mut fidl::encoding::Encoder<'_, D>,
2473 offset: usize,
2474 _depth: fidl::encoding::Depth,
2475 ) -> fidl::Result<()> {
2476 encoder.debug_check_bounds::<ProfileConnectRequest>(offset);
2477 fidl::encoding::Encode::<ProfileConnectRequest, D>::encode(
2479 (
2480 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
2481 <ConnectParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.connection),
2482 ),
2483 encoder, offset, _depth
2484 )
2485 }
2486 }
2487 unsafe impl<
2488 D: fidl::encoding::ResourceDialect,
2489 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2490 T1: fidl::encoding::Encode<ConnectParameters, D>,
2491 > fidl::encoding::Encode<ProfileConnectRequest, D> for (T0, T1)
2492 {
2493 #[inline]
2494 unsafe fn encode(
2495 self,
2496 encoder: &mut fidl::encoding::Encoder<'_, D>,
2497 offset: usize,
2498 depth: fidl::encoding::Depth,
2499 ) -> fidl::Result<()> {
2500 encoder.debug_check_bounds::<ProfileConnectRequest>(offset);
2501 self.0.encode(encoder, offset + 0, depth)?;
2505 self.1.encode(encoder, offset + 8, depth)?;
2506 Ok(())
2507 }
2508 }
2509
2510 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProfileConnectRequest {
2511 #[inline(always)]
2512 fn new_empty() -> Self {
2513 Self {
2514 peer_id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
2515 connection: fidl::new_empty!(ConnectParameters, D),
2516 }
2517 }
2518
2519 #[inline]
2520 unsafe fn decode(
2521 &mut self,
2522 decoder: &mut fidl::encoding::Decoder<'_, D>,
2523 offset: usize,
2524 _depth: fidl::encoding::Depth,
2525 ) -> fidl::Result<()> {
2526 decoder.debug_check_bounds::<Self>(offset);
2527 fidl::decode!(
2529 fidl_fuchsia_bluetooth__common::PeerId,
2530 D,
2531 &mut self.peer_id,
2532 decoder,
2533 offset + 0,
2534 _depth
2535 )?;
2536 fidl::decode!(ConnectParameters, D, &mut self.connection, decoder, offset + 8, _depth)?;
2537 Ok(())
2538 }
2539 }
2540
2541 impl fidl::encoding::ValueTypeMarker for SearchResultsServiceFoundRequest {
2542 type Borrowed<'a> = &'a Self;
2543 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2544 value
2545 }
2546 }
2547
2548 unsafe impl fidl::encoding::TypeMarker for SearchResultsServiceFoundRequest {
2549 type Owned = Self;
2550
2551 #[inline(always)]
2552 fn inline_align(_context: fidl::encoding::Context) -> usize {
2553 8
2554 }
2555
2556 #[inline(always)]
2557 fn inline_size(_context: fidl::encoding::Context) -> usize {
2558 40
2559 }
2560 }
2561
2562 unsafe impl<D: fidl::encoding::ResourceDialect>
2563 fidl::encoding::Encode<SearchResultsServiceFoundRequest, D>
2564 for &SearchResultsServiceFoundRequest
2565 {
2566 #[inline]
2567 unsafe fn encode(
2568 self,
2569 encoder: &mut fidl::encoding::Encoder<'_, D>,
2570 offset: usize,
2571 _depth: fidl::encoding::Depth,
2572 ) -> fidl::Result<()> {
2573 encoder.debug_check_bounds::<SearchResultsServiceFoundRequest>(offset);
2574 fidl::encoding::Encode::<SearchResultsServiceFoundRequest, D>::encode(
2576 (
2577 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_id),
2578 <fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>> as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),
2579 <fidl::encoding::Vector<Attribute, 512> as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
2580 ),
2581 encoder, offset, _depth
2582 )
2583 }
2584 }
2585 unsafe impl<
2586 D: fidl::encoding::ResourceDialect,
2587 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2588 T1: fidl::encoding::Encode<
2589 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2590 D,
2591 >,
2592 T2: fidl::encoding::Encode<fidl::encoding::Vector<Attribute, 512>, D>,
2593 > fidl::encoding::Encode<SearchResultsServiceFoundRequest, D> for (T0, T1, T2)
2594 {
2595 #[inline]
2596 unsafe fn encode(
2597 self,
2598 encoder: &mut fidl::encoding::Encoder<'_, D>,
2599 offset: usize,
2600 depth: fidl::encoding::Depth,
2601 ) -> fidl::Result<()> {
2602 encoder.debug_check_bounds::<SearchResultsServiceFoundRequest>(offset);
2603 self.0.encode(encoder, offset + 0, depth)?;
2607 self.1.encode(encoder, offset + 8, depth)?;
2608 self.2.encode(encoder, offset + 24, depth)?;
2609 Ok(())
2610 }
2611 }
2612
2613 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2614 for SearchResultsServiceFoundRequest
2615 {
2616 #[inline(always)]
2617 fn new_empty() -> Self {
2618 Self {
2619 peer_id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
2620 protocol: fidl::new_empty!(
2621 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2622 D
2623 ),
2624 attributes: fidl::new_empty!(fidl::encoding::Vector<Attribute, 512>, D),
2625 }
2626 }
2627
2628 #[inline]
2629 unsafe fn decode(
2630 &mut self,
2631 decoder: &mut fidl::encoding::Decoder<'_, D>,
2632 offset: usize,
2633 _depth: fidl::encoding::Depth,
2634 ) -> fidl::Result<()> {
2635 decoder.debug_check_bounds::<Self>(offset);
2636 fidl::decode!(
2638 fidl_fuchsia_bluetooth__common::PeerId,
2639 D,
2640 &mut self.peer_id,
2641 decoder,
2642 offset + 0,
2643 _depth
2644 )?;
2645 fidl::decode!(
2646 fidl::encoding::Optional<fidl::encoding::Vector<ProtocolDescriptor, 255>>,
2647 D,
2648 &mut self.protocol,
2649 decoder,
2650 offset + 8,
2651 _depth
2652 )?;
2653 fidl::decode!(fidl::encoding::Vector<Attribute, 512>, D, &mut self.attributes, decoder, offset + 24, _depth)?;
2654 Ok(())
2655 }
2656 }
2657
2658 impl Attribute {
2659 #[inline(always)]
2660 fn max_ordinal_present(&self) -> u64 {
2661 if let Some(_) = self.element {
2662 return 2;
2663 }
2664 if let Some(_) = self.id {
2665 return 1;
2666 }
2667 0
2668 }
2669 }
2670
2671 impl fidl::encoding::ValueTypeMarker for Attribute {
2672 type Borrowed<'a> = &'a Self;
2673 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2674 value
2675 }
2676 }
2677
2678 unsafe impl fidl::encoding::TypeMarker for Attribute {
2679 type Owned = Self;
2680
2681 #[inline(always)]
2682 fn inline_align(_context: fidl::encoding::Context) -> usize {
2683 8
2684 }
2685
2686 #[inline(always)]
2687 fn inline_size(_context: fidl::encoding::Context) -> usize {
2688 16
2689 }
2690 }
2691
2692 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Attribute, D>
2693 for &Attribute
2694 {
2695 unsafe fn encode(
2696 self,
2697 encoder: &mut fidl::encoding::Encoder<'_, D>,
2698 offset: usize,
2699 mut depth: fidl::encoding::Depth,
2700 ) -> fidl::Result<()> {
2701 encoder.debug_check_bounds::<Attribute>(offset);
2702 let max_ordinal: u64 = self.max_ordinal_present();
2704 encoder.write_num(max_ordinal, offset);
2705 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2706 if max_ordinal == 0 {
2708 return Ok(());
2709 }
2710 depth.increment()?;
2711 let envelope_size = 8;
2712 let bytes_len = max_ordinal as usize * envelope_size;
2713 #[allow(unused_variables)]
2714 let offset = encoder.out_of_line_offset(bytes_len);
2715 let mut _prev_end_offset: usize = 0;
2716 if 1 > max_ordinal {
2717 return Ok(());
2718 }
2719
2720 let cur_offset: usize = (1 - 1) * envelope_size;
2723
2724 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2726
2727 fidl::encoding::encode_in_envelope_optional::<u16, D>(
2732 self.id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2733 encoder,
2734 offset + cur_offset,
2735 depth,
2736 )?;
2737
2738 _prev_end_offset = cur_offset + envelope_size;
2739 if 2 > max_ordinal {
2740 return Ok(());
2741 }
2742
2743 let cur_offset: usize = (2 - 1) * envelope_size;
2746
2747 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2749
2750 fidl::encoding::encode_in_envelope_optional::<DataElement, D>(
2755 self.element.as_ref().map(<DataElement as fidl::encoding::ValueTypeMarker>::borrow),
2756 encoder,
2757 offset + cur_offset,
2758 depth,
2759 )?;
2760
2761 _prev_end_offset = cur_offset + envelope_size;
2762
2763 Ok(())
2764 }
2765 }
2766
2767 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Attribute {
2768 #[inline(always)]
2769 fn new_empty() -> Self {
2770 Self::default()
2771 }
2772
2773 unsafe fn decode(
2774 &mut self,
2775 decoder: &mut fidl::encoding::Decoder<'_, D>,
2776 offset: usize,
2777 mut depth: fidl::encoding::Depth,
2778 ) -> fidl::Result<()> {
2779 decoder.debug_check_bounds::<Self>(offset);
2780 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2781 None => return Err(fidl::Error::NotNullable),
2782 Some(len) => len,
2783 };
2784 if len == 0 {
2786 return Ok(());
2787 };
2788 depth.increment()?;
2789 let envelope_size = 8;
2790 let bytes_len = len * envelope_size;
2791 let offset = decoder.out_of_line_offset(bytes_len)?;
2792 let mut _next_ordinal_to_read = 0;
2794 let mut next_offset = offset;
2795 let end_offset = offset + bytes_len;
2796 _next_ordinal_to_read += 1;
2797 if next_offset >= end_offset {
2798 return Ok(());
2799 }
2800
2801 while _next_ordinal_to_read < 1 {
2803 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2804 _next_ordinal_to_read += 1;
2805 next_offset += envelope_size;
2806 }
2807
2808 let next_out_of_line = decoder.next_out_of_line();
2809 let handles_before = decoder.remaining_handles();
2810 if let Some((inlined, num_bytes, num_handles)) =
2811 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2812 {
2813 let member_inline_size =
2814 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2815 if inlined != (member_inline_size <= 4) {
2816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2817 }
2818 let inner_offset;
2819 let mut inner_depth = depth.clone();
2820 if inlined {
2821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2822 inner_offset = next_offset;
2823 } else {
2824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2825 inner_depth.increment()?;
2826 }
2827 let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u16, D));
2828 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2829 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2830 {
2831 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2832 }
2833 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2834 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2835 }
2836 }
2837
2838 next_offset += envelope_size;
2839 _next_ordinal_to_read += 1;
2840 if next_offset >= end_offset {
2841 return Ok(());
2842 }
2843
2844 while _next_ordinal_to_read < 2 {
2846 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2847 _next_ordinal_to_read += 1;
2848 next_offset += envelope_size;
2849 }
2850
2851 let next_out_of_line = decoder.next_out_of_line();
2852 let handles_before = decoder.remaining_handles();
2853 if let Some((inlined, num_bytes, num_handles)) =
2854 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2855 {
2856 let member_inline_size =
2857 <DataElement as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2858 if inlined != (member_inline_size <= 4) {
2859 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2860 }
2861 let inner_offset;
2862 let mut inner_depth = depth.clone();
2863 if inlined {
2864 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2865 inner_offset = next_offset;
2866 } else {
2867 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2868 inner_depth.increment()?;
2869 }
2870 let val_ref = self.element.get_or_insert_with(|| fidl::new_empty!(DataElement, D));
2871 fidl::decode!(DataElement, D, val_ref, decoder, inner_offset, inner_depth)?;
2872 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2873 {
2874 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2875 }
2876 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2877 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2878 }
2879 }
2880
2881 next_offset += envelope_size;
2882
2883 while next_offset < end_offset {
2885 _next_ordinal_to_read += 1;
2886 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2887 next_offset += envelope_size;
2888 }
2889
2890 Ok(())
2891 }
2892 }
2893
2894 impl AudioAacSupport {
2895 #[inline(always)]
2896 fn max_ordinal_present(&self) -> u64 {
2897 0
2898 }
2899 }
2900
2901 impl fidl::encoding::ValueTypeMarker for AudioAacSupport {
2902 type Borrowed<'a> = &'a Self;
2903 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2904 value
2905 }
2906 }
2907
2908 unsafe impl fidl::encoding::TypeMarker for AudioAacSupport {
2909 type Owned = Self;
2910
2911 #[inline(always)]
2912 fn inline_align(_context: fidl::encoding::Context) -> usize {
2913 8
2914 }
2915
2916 #[inline(always)]
2917 fn inline_size(_context: fidl::encoding::Context) -> usize {
2918 16
2919 }
2920 }
2921
2922 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioAacSupport, D>
2923 for &AudioAacSupport
2924 {
2925 unsafe fn encode(
2926 self,
2927 encoder: &mut fidl::encoding::Encoder<'_, D>,
2928 offset: usize,
2929 mut depth: fidl::encoding::Depth,
2930 ) -> fidl::Result<()> {
2931 encoder.debug_check_bounds::<AudioAacSupport>(offset);
2932 let max_ordinal: u64 = self.max_ordinal_present();
2934 encoder.write_num(max_ordinal, offset);
2935 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2936 if max_ordinal == 0 {
2938 return Ok(());
2939 }
2940 depth.increment()?;
2941 let envelope_size = 8;
2942 let bytes_len = max_ordinal as usize * envelope_size;
2943 #[allow(unused_variables)]
2944 let offset = encoder.out_of_line_offset(bytes_len);
2945 let mut _prev_end_offset: usize = 0;
2946
2947 Ok(())
2948 }
2949 }
2950
2951 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioAacSupport {
2952 #[inline(always)]
2953 fn new_empty() -> Self {
2954 Self::default()
2955 }
2956
2957 unsafe fn decode(
2958 &mut self,
2959 decoder: &mut fidl::encoding::Decoder<'_, D>,
2960 offset: usize,
2961 mut depth: fidl::encoding::Depth,
2962 ) -> fidl::Result<()> {
2963 decoder.debug_check_bounds::<Self>(offset);
2964 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2965 None => return Err(fidl::Error::NotNullable),
2966 Some(len) => len,
2967 };
2968 if len == 0 {
2970 return Ok(());
2971 };
2972 depth.increment()?;
2973 let envelope_size = 8;
2974 let bytes_len = len * envelope_size;
2975 let offset = decoder.out_of_line_offset(bytes_len)?;
2976 let mut _next_ordinal_to_read = 0;
2978 let mut next_offset = offset;
2979 let end_offset = offset + bytes_len;
2980
2981 while next_offset < end_offset {
2983 _next_ordinal_to_read += 1;
2984 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2985 next_offset += envelope_size;
2986 }
2987
2988 Ok(())
2989 }
2990 }
2991
2992 impl AudioOffloadConfiguration {
2993 #[inline(always)]
2994 fn max_ordinal_present(&self) -> u64 {
2995 if let Some(_) = self.encoder_settings {
2996 return 8;
2997 }
2998 if let Some(_) = self.encoded_bit_rate {
2999 return 7;
3000 }
3001 if let Some(_) = self.channel_mode {
3002 return 6;
3003 }
3004 if let Some(_) = self.bits_per_sample {
3005 return 5;
3006 }
3007 if let Some(_) = self.sampling_frequency {
3008 return 4;
3009 }
3010 if let Some(_) = self.scms_t_enable {
3011 return 3;
3012 }
3013 if let Some(_) = self.max_latency {
3014 return 2;
3015 }
3016 if let Some(_) = self.codec {
3017 return 1;
3018 }
3019 0
3020 }
3021 }
3022
3023 impl fidl::encoding::ValueTypeMarker for AudioOffloadConfiguration {
3024 type Borrowed<'a> = &'a Self;
3025 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3026 value
3027 }
3028 }
3029
3030 unsafe impl fidl::encoding::TypeMarker for AudioOffloadConfiguration {
3031 type Owned = Self;
3032
3033 #[inline(always)]
3034 fn inline_align(_context: fidl::encoding::Context) -> usize {
3035 8
3036 }
3037
3038 #[inline(always)]
3039 fn inline_size(_context: fidl::encoding::Context) -> usize {
3040 16
3041 }
3042 }
3043
3044 unsafe impl<D: fidl::encoding::ResourceDialect>
3045 fidl::encoding::Encode<AudioOffloadConfiguration, D> for &AudioOffloadConfiguration
3046 {
3047 unsafe fn encode(
3048 self,
3049 encoder: &mut fidl::encoding::Encoder<'_, D>,
3050 offset: usize,
3051 mut depth: fidl::encoding::Depth,
3052 ) -> fidl::Result<()> {
3053 encoder.debug_check_bounds::<AudioOffloadConfiguration>(offset);
3054 let max_ordinal: u64 = self.max_ordinal_present();
3056 encoder.write_num(max_ordinal, offset);
3057 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3058 if max_ordinal == 0 {
3060 return Ok(());
3061 }
3062 depth.increment()?;
3063 let envelope_size = 8;
3064 let bytes_len = max_ordinal as usize * envelope_size;
3065 #[allow(unused_variables)]
3066 let offset = encoder.out_of_line_offset(bytes_len);
3067 let mut _prev_end_offset: usize = 0;
3068 if 1 > max_ordinal {
3069 return Ok(());
3070 }
3071
3072 let cur_offset: usize = (1 - 1) * envelope_size;
3075
3076 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3078
3079 fidl::encoding::encode_in_envelope_optional::<AudioOffloadFeatures, D>(
3084 self.codec
3085 .as_ref()
3086 .map(<AudioOffloadFeatures as fidl::encoding::ValueTypeMarker>::borrow),
3087 encoder,
3088 offset + cur_offset,
3089 depth,
3090 )?;
3091
3092 _prev_end_offset = cur_offset + envelope_size;
3093 if 2 > max_ordinal {
3094 return Ok(());
3095 }
3096
3097 let cur_offset: usize = (2 - 1) * envelope_size;
3100
3101 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3103
3104 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3109 self.max_latency.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3110 encoder,
3111 offset + cur_offset,
3112 depth,
3113 )?;
3114
3115 _prev_end_offset = cur_offset + envelope_size;
3116 if 3 > max_ordinal {
3117 return Ok(());
3118 }
3119
3120 let cur_offset: usize = (3 - 1) * envelope_size;
3123
3124 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3126
3127 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3132 self.scms_t_enable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3133 encoder,
3134 offset + cur_offset,
3135 depth,
3136 )?;
3137
3138 _prev_end_offset = cur_offset + envelope_size;
3139 if 4 > max_ordinal {
3140 return Ok(());
3141 }
3142
3143 let cur_offset: usize = (4 - 1) * envelope_size;
3146
3147 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3149
3150 fidl::encoding::encode_in_envelope_optional::<AudioSamplingFrequency, D>(
3155 self.sampling_frequency
3156 .as_ref()
3157 .map(<AudioSamplingFrequency as fidl::encoding::ValueTypeMarker>::borrow),
3158 encoder,
3159 offset + cur_offset,
3160 depth,
3161 )?;
3162
3163 _prev_end_offset = cur_offset + envelope_size;
3164 if 5 > max_ordinal {
3165 return Ok(());
3166 }
3167
3168 let cur_offset: usize = (5 - 1) * envelope_size;
3171
3172 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3174
3175 fidl::encoding::encode_in_envelope_optional::<AudioBitsPerSample, D>(
3180 self.bits_per_sample
3181 .as_ref()
3182 .map(<AudioBitsPerSample as fidl::encoding::ValueTypeMarker>::borrow),
3183 encoder,
3184 offset + cur_offset,
3185 depth,
3186 )?;
3187
3188 _prev_end_offset = cur_offset + envelope_size;
3189 if 6 > max_ordinal {
3190 return Ok(());
3191 }
3192
3193 let cur_offset: usize = (6 - 1) * envelope_size;
3196
3197 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3199
3200 fidl::encoding::encode_in_envelope_optional::<AudioChannelMode, D>(
3205 self.channel_mode
3206 .as_ref()
3207 .map(<AudioChannelMode as fidl::encoding::ValueTypeMarker>::borrow),
3208 encoder,
3209 offset + cur_offset,
3210 depth,
3211 )?;
3212
3213 _prev_end_offset = cur_offset + envelope_size;
3214 if 7 > max_ordinal {
3215 return Ok(());
3216 }
3217
3218 let cur_offset: usize = (7 - 1) * envelope_size;
3221
3222 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3224
3225 fidl::encoding::encode_in_envelope_optional::<u32, D>(
3230 self.encoded_bit_rate
3231 .as_ref()
3232 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3233 encoder,
3234 offset + cur_offset,
3235 depth,
3236 )?;
3237
3238 _prev_end_offset = cur_offset + envelope_size;
3239 if 8 > max_ordinal {
3240 return Ok(());
3241 }
3242
3243 let cur_offset: usize = (8 - 1) * envelope_size;
3246
3247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250 fidl::encoding::encode_in_envelope_optional::<AudioEncoderSettings, D>(
3255 self.encoder_settings
3256 .as_ref()
3257 .map(<AudioEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow),
3258 encoder,
3259 offset + cur_offset,
3260 depth,
3261 )?;
3262
3263 _prev_end_offset = cur_offset + envelope_size;
3264
3265 Ok(())
3266 }
3267 }
3268
3269 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3270 for AudioOffloadConfiguration
3271 {
3272 #[inline(always)]
3273 fn new_empty() -> Self {
3274 Self::default()
3275 }
3276
3277 unsafe fn decode(
3278 &mut self,
3279 decoder: &mut fidl::encoding::Decoder<'_, D>,
3280 offset: usize,
3281 mut depth: fidl::encoding::Depth,
3282 ) -> fidl::Result<()> {
3283 decoder.debug_check_bounds::<Self>(offset);
3284 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3285 None => return Err(fidl::Error::NotNullable),
3286 Some(len) => len,
3287 };
3288 if len == 0 {
3290 return Ok(());
3291 };
3292 depth.increment()?;
3293 let envelope_size = 8;
3294 let bytes_len = len * envelope_size;
3295 let offset = decoder.out_of_line_offset(bytes_len)?;
3296 let mut _next_ordinal_to_read = 0;
3298 let mut next_offset = offset;
3299 let end_offset = offset + bytes_len;
3300 _next_ordinal_to_read += 1;
3301 if next_offset >= end_offset {
3302 return Ok(());
3303 }
3304
3305 while _next_ordinal_to_read < 1 {
3307 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3308 _next_ordinal_to_read += 1;
3309 next_offset += envelope_size;
3310 }
3311
3312 let next_out_of_line = decoder.next_out_of_line();
3313 let handles_before = decoder.remaining_handles();
3314 if let Some((inlined, num_bytes, num_handles)) =
3315 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3316 {
3317 let member_inline_size =
3318 <AudioOffloadFeatures as fidl::encoding::TypeMarker>::inline_size(
3319 decoder.context,
3320 );
3321 if inlined != (member_inline_size <= 4) {
3322 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3323 }
3324 let inner_offset;
3325 let mut inner_depth = depth.clone();
3326 if inlined {
3327 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3328 inner_offset = next_offset;
3329 } else {
3330 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3331 inner_depth.increment()?;
3332 }
3333 let val_ref =
3334 self.codec.get_or_insert_with(|| fidl::new_empty!(AudioOffloadFeatures, D));
3335 fidl::decode!(
3336 AudioOffloadFeatures,
3337 D,
3338 val_ref,
3339 decoder,
3340 inner_offset,
3341 inner_depth
3342 )?;
3343 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3344 {
3345 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3346 }
3347 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3348 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3349 }
3350 }
3351
3352 next_offset += envelope_size;
3353 _next_ordinal_to_read += 1;
3354 if next_offset >= end_offset {
3355 return Ok(());
3356 }
3357
3358 while _next_ordinal_to_read < 2 {
3360 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3361 _next_ordinal_to_read += 1;
3362 next_offset += envelope_size;
3363 }
3364
3365 let next_out_of_line = decoder.next_out_of_line();
3366 let handles_before = decoder.remaining_handles();
3367 if let Some((inlined, num_bytes, num_handles)) =
3368 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3369 {
3370 let member_inline_size =
3371 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3372 if inlined != (member_inline_size <= 4) {
3373 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3374 }
3375 let inner_offset;
3376 let mut inner_depth = depth.clone();
3377 if inlined {
3378 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3379 inner_offset = next_offset;
3380 } else {
3381 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3382 inner_depth.increment()?;
3383 }
3384 let val_ref = self.max_latency.get_or_insert_with(|| fidl::new_empty!(u16, D));
3385 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3386 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3387 {
3388 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3389 }
3390 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3391 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3392 }
3393 }
3394
3395 next_offset += envelope_size;
3396 _next_ordinal_to_read += 1;
3397 if next_offset >= end_offset {
3398 return Ok(());
3399 }
3400
3401 while _next_ordinal_to_read < 3 {
3403 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3404 _next_ordinal_to_read += 1;
3405 next_offset += envelope_size;
3406 }
3407
3408 let next_out_of_line = decoder.next_out_of_line();
3409 let handles_before = decoder.remaining_handles();
3410 if let Some((inlined, num_bytes, num_handles)) =
3411 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3412 {
3413 let member_inline_size =
3414 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
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.scms_t_enable.get_or_insert_with(|| fidl::new_empty!(bool, D));
3428 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3430 {
3431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3432 }
3433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3435 }
3436 }
3437
3438 next_offset += envelope_size;
3439 _next_ordinal_to_read += 1;
3440 if next_offset >= end_offset {
3441 return Ok(());
3442 }
3443
3444 while _next_ordinal_to_read < 4 {
3446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3447 _next_ordinal_to_read += 1;
3448 next_offset += envelope_size;
3449 }
3450
3451 let next_out_of_line = decoder.next_out_of_line();
3452 let handles_before = decoder.remaining_handles();
3453 if let Some((inlined, num_bytes, num_handles)) =
3454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3455 {
3456 let member_inline_size =
3457 <AudioSamplingFrequency as fidl::encoding::TypeMarker>::inline_size(
3458 decoder.context,
3459 );
3460 if inlined != (member_inline_size <= 4) {
3461 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3462 }
3463 let inner_offset;
3464 let mut inner_depth = depth.clone();
3465 if inlined {
3466 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3467 inner_offset = next_offset;
3468 } else {
3469 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3470 inner_depth.increment()?;
3471 }
3472 let val_ref = self
3473 .sampling_frequency
3474 .get_or_insert_with(|| fidl::new_empty!(AudioSamplingFrequency, D));
3475 fidl::decode!(
3476 AudioSamplingFrequency,
3477 D,
3478 val_ref,
3479 decoder,
3480 inner_offset,
3481 inner_depth
3482 )?;
3483 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3484 {
3485 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3486 }
3487 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3488 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3489 }
3490 }
3491
3492 next_offset += envelope_size;
3493 _next_ordinal_to_read += 1;
3494 if next_offset >= end_offset {
3495 return Ok(());
3496 }
3497
3498 while _next_ordinal_to_read < 5 {
3500 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3501 _next_ordinal_to_read += 1;
3502 next_offset += envelope_size;
3503 }
3504
3505 let next_out_of_line = decoder.next_out_of_line();
3506 let handles_before = decoder.remaining_handles();
3507 if let Some((inlined, num_bytes, num_handles)) =
3508 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3509 {
3510 let member_inline_size =
3511 <AudioBitsPerSample as fidl::encoding::TypeMarker>::inline_size(
3512 decoder.context,
3513 );
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 = self
3527 .bits_per_sample
3528 .get_or_insert_with(|| fidl::new_empty!(AudioBitsPerSample, D));
3529 fidl::decode!(AudioBitsPerSample, D, val_ref, decoder, inner_offset, inner_depth)?;
3530 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3531 {
3532 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3533 }
3534 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3535 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3536 }
3537 }
3538
3539 next_offset += envelope_size;
3540 _next_ordinal_to_read += 1;
3541 if next_offset >= end_offset {
3542 return Ok(());
3543 }
3544
3545 while _next_ordinal_to_read < 6 {
3547 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3548 _next_ordinal_to_read += 1;
3549 next_offset += envelope_size;
3550 }
3551
3552 let next_out_of_line = decoder.next_out_of_line();
3553 let handles_before = decoder.remaining_handles();
3554 if let Some((inlined, num_bytes, num_handles)) =
3555 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3556 {
3557 let member_inline_size =
3558 <AudioChannelMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3559 if inlined != (member_inline_size <= 4) {
3560 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3561 }
3562 let inner_offset;
3563 let mut inner_depth = depth.clone();
3564 if inlined {
3565 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3566 inner_offset = next_offset;
3567 } else {
3568 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3569 inner_depth.increment()?;
3570 }
3571 let val_ref =
3572 self.channel_mode.get_or_insert_with(|| fidl::new_empty!(AudioChannelMode, D));
3573 fidl::decode!(AudioChannelMode, D, val_ref, decoder, inner_offset, inner_depth)?;
3574 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3575 {
3576 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3577 }
3578 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3579 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3580 }
3581 }
3582
3583 next_offset += envelope_size;
3584 _next_ordinal_to_read += 1;
3585 if next_offset >= end_offset {
3586 return Ok(());
3587 }
3588
3589 while _next_ordinal_to_read < 7 {
3591 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3592 _next_ordinal_to_read += 1;
3593 next_offset += envelope_size;
3594 }
3595
3596 let next_out_of_line = decoder.next_out_of_line();
3597 let handles_before = decoder.remaining_handles();
3598 if let Some((inlined, num_bytes, num_handles)) =
3599 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3600 {
3601 let member_inline_size =
3602 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
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.encoded_bit_rate.get_or_insert_with(|| fidl::new_empty!(u32, D));
3616 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3617 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3618 {
3619 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3620 }
3621 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3622 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3623 }
3624 }
3625
3626 next_offset += envelope_size;
3627 _next_ordinal_to_read += 1;
3628 if next_offset >= end_offset {
3629 return Ok(());
3630 }
3631
3632 while _next_ordinal_to_read < 8 {
3634 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3635 _next_ordinal_to_read += 1;
3636 next_offset += envelope_size;
3637 }
3638
3639 let next_out_of_line = decoder.next_out_of_line();
3640 let handles_before = decoder.remaining_handles();
3641 if let Some((inlined, num_bytes, num_handles)) =
3642 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3643 {
3644 let member_inline_size =
3645 <AudioEncoderSettings as fidl::encoding::TypeMarker>::inline_size(
3646 decoder.context,
3647 );
3648 if inlined != (member_inline_size <= 4) {
3649 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3650 }
3651 let inner_offset;
3652 let mut inner_depth = depth.clone();
3653 if inlined {
3654 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3655 inner_offset = next_offset;
3656 } else {
3657 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3658 inner_depth.increment()?;
3659 }
3660 let val_ref = self
3661 .encoder_settings
3662 .get_or_insert_with(|| fidl::new_empty!(AudioEncoderSettings, D));
3663 fidl::decode!(
3664 AudioEncoderSettings,
3665 D,
3666 val_ref,
3667 decoder,
3668 inner_offset,
3669 inner_depth
3670 )?;
3671 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3672 {
3673 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3674 }
3675 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3676 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3677 }
3678 }
3679
3680 next_offset += envelope_size;
3681
3682 while next_offset < end_offset {
3684 _next_ordinal_to_read += 1;
3685 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3686 next_offset += envelope_size;
3687 }
3688
3689 Ok(())
3690 }
3691 }
3692
3693 impl AudioOffloadExtGetSupportedFeaturesResponse {
3694 #[inline(always)]
3695 fn max_ordinal_present(&self) -> u64 {
3696 if let Some(_) = self.audio_offload_features {
3697 return 1;
3698 }
3699 0
3700 }
3701 }
3702
3703 impl fidl::encoding::ValueTypeMarker for AudioOffloadExtGetSupportedFeaturesResponse {
3704 type Borrowed<'a> = &'a Self;
3705 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3706 value
3707 }
3708 }
3709
3710 unsafe impl fidl::encoding::TypeMarker for AudioOffloadExtGetSupportedFeaturesResponse {
3711 type Owned = Self;
3712
3713 #[inline(always)]
3714 fn inline_align(_context: fidl::encoding::Context) -> usize {
3715 8
3716 }
3717
3718 #[inline(always)]
3719 fn inline_size(_context: fidl::encoding::Context) -> usize {
3720 16
3721 }
3722 }
3723
3724 unsafe impl<D: fidl::encoding::ResourceDialect>
3725 fidl::encoding::Encode<AudioOffloadExtGetSupportedFeaturesResponse, D>
3726 for &AudioOffloadExtGetSupportedFeaturesResponse
3727 {
3728 unsafe fn encode(
3729 self,
3730 encoder: &mut fidl::encoding::Encoder<'_, D>,
3731 offset: usize,
3732 mut depth: fidl::encoding::Depth,
3733 ) -> fidl::Result<()> {
3734 encoder.debug_check_bounds::<AudioOffloadExtGetSupportedFeaturesResponse>(offset);
3735 let max_ordinal: u64 = self.max_ordinal_present();
3737 encoder.write_num(max_ordinal, offset);
3738 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3739 if max_ordinal == 0 {
3741 return Ok(());
3742 }
3743 depth.increment()?;
3744 let envelope_size = 8;
3745 let bytes_len = max_ordinal as usize * envelope_size;
3746 #[allow(unused_variables)]
3747 let offset = encoder.out_of_line_offset(bytes_len);
3748 let mut _prev_end_offset: usize = 0;
3749 if 1 > max_ordinal {
3750 return Ok(());
3751 }
3752
3753 let cur_offset: usize = (1 - 1) * envelope_size;
3756
3757 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3759
3760 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AudioOffloadFeatures>, D>(
3765 self.audio_offload_features.as_ref().map(<fidl::encoding::UnboundedVector<AudioOffloadFeatures> as fidl::encoding::ValueTypeMarker>::borrow),
3766 encoder, offset + cur_offset, depth
3767 )?;
3768
3769 _prev_end_offset = cur_offset + envelope_size;
3770
3771 Ok(())
3772 }
3773 }
3774
3775 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3776 for AudioOffloadExtGetSupportedFeaturesResponse
3777 {
3778 #[inline(always)]
3779 fn new_empty() -> Self {
3780 Self::default()
3781 }
3782
3783 unsafe fn decode(
3784 &mut self,
3785 decoder: &mut fidl::encoding::Decoder<'_, D>,
3786 offset: usize,
3787 mut depth: fidl::encoding::Depth,
3788 ) -> fidl::Result<()> {
3789 decoder.debug_check_bounds::<Self>(offset);
3790 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3791 None => return Err(fidl::Error::NotNullable),
3792 Some(len) => len,
3793 };
3794 if len == 0 {
3796 return Ok(());
3797 };
3798 depth.increment()?;
3799 let envelope_size = 8;
3800 let bytes_len = len * envelope_size;
3801 let offset = decoder.out_of_line_offset(bytes_len)?;
3802 let mut _next_ordinal_to_read = 0;
3804 let mut next_offset = offset;
3805 let end_offset = offset + bytes_len;
3806 _next_ordinal_to_read += 1;
3807 if next_offset >= end_offset {
3808 return Ok(());
3809 }
3810
3811 while _next_ordinal_to_read < 1 {
3813 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3814 _next_ordinal_to_read += 1;
3815 next_offset += envelope_size;
3816 }
3817
3818 let next_out_of_line = decoder.next_out_of_line();
3819 let handles_before = decoder.remaining_handles();
3820 if let Some((inlined, num_bytes, num_handles)) =
3821 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3822 {
3823 let member_inline_size = <fidl::encoding::UnboundedVector<AudioOffloadFeatures> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3824 if inlined != (member_inline_size <= 4) {
3825 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3826 }
3827 let inner_offset;
3828 let mut inner_depth = depth.clone();
3829 if inlined {
3830 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3831 inner_offset = next_offset;
3832 } else {
3833 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3834 inner_depth.increment()?;
3835 }
3836 let val_ref = self.audio_offload_features.get_or_insert_with(|| {
3837 fidl::new_empty!(fidl::encoding::UnboundedVector<AudioOffloadFeatures>, D)
3838 });
3839 fidl::decode!(
3840 fidl::encoding::UnboundedVector<AudioOffloadFeatures>,
3841 D,
3842 val_ref,
3843 decoder,
3844 inner_offset,
3845 inner_depth
3846 )?;
3847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848 {
3849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850 }
3851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853 }
3854 }
3855
3856 next_offset += envelope_size;
3857
3858 while next_offset < end_offset {
3860 _next_ordinal_to_read += 1;
3861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3862 next_offset += envelope_size;
3863 }
3864
3865 Ok(())
3866 }
3867 }
3868
3869 impl AudioSbcSupport {
3870 #[inline(always)]
3871 fn max_ordinal_present(&self) -> u64 {
3872 0
3873 }
3874 }
3875
3876 impl fidl::encoding::ValueTypeMarker for AudioSbcSupport {
3877 type Borrowed<'a> = &'a Self;
3878 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3879 value
3880 }
3881 }
3882
3883 unsafe impl fidl::encoding::TypeMarker for AudioSbcSupport {
3884 type Owned = Self;
3885
3886 #[inline(always)]
3887 fn inline_align(_context: fidl::encoding::Context) -> usize {
3888 8
3889 }
3890
3891 #[inline(always)]
3892 fn inline_size(_context: fidl::encoding::Context) -> usize {
3893 16
3894 }
3895 }
3896
3897 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioSbcSupport, D>
3898 for &AudioSbcSupport
3899 {
3900 unsafe fn encode(
3901 self,
3902 encoder: &mut fidl::encoding::Encoder<'_, D>,
3903 offset: usize,
3904 mut depth: fidl::encoding::Depth,
3905 ) -> fidl::Result<()> {
3906 encoder.debug_check_bounds::<AudioSbcSupport>(offset);
3907 let max_ordinal: u64 = self.max_ordinal_present();
3909 encoder.write_num(max_ordinal, offset);
3910 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3911 if max_ordinal == 0 {
3913 return Ok(());
3914 }
3915 depth.increment()?;
3916 let envelope_size = 8;
3917 let bytes_len = max_ordinal as usize * envelope_size;
3918 #[allow(unused_variables)]
3919 let offset = encoder.out_of_line_offset(bytes_len);
3920 let mut _prev_end_offset: usize = 0;
3921
3922 Ok(())
3923 }
3924 }
3925
3926 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioSbcSupport {
3927 #[inline(always)]
3928 fn new_empty() -> Self {
3929 Self::default()
3930 }
3931
3932 unsafe fn decode(
3933 &mut self,
3934 decoder: &mut fidl::encoding::Decoder<'_, D>,
3935 offset: usize,
3936 mut depth: fidl::encoding::Depth,
3937 ) -> fidl::Result<()> {
3938 decoder.debug_check_bounds::<Self>(offset);
3939 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3940 None => return Err(fidl::Error::NotNullable),
3941 Some(len) => len,
3942 };
3943 if len == 0 {
3945 return Ok(());
3946 };
3947 depth.increment()?;
3948 let envelope_size = 8;
3949 let bytes_len = len * envelope_size;
3950 let offset = decoder.out_of_line_offset(bytes_len)?;
3951 let mut _next_ordinal_to_read = 0;
3953 let mut next_offset = offset;
3954 let end_offset = offset + bytes_len;
3955
3956 while next_offset < end_offset {
3958 _next_ordinal_to_read += 1;
3959 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3960 next_offset += envelope_size;
3961 }
3962
3963 Ok(())
3964 }
3965 }
3966
3967 impl Information {
3968 #[inline(always)]
3969 fn max_ordinal_present(&self) -> u64 {
3970 if let Some(_) = self.provider {
3971 return 4;
3972 }
3973 if let Some(_) = self.description {
3974 return 3;
3975 }
3976 if let Some(_) = self.name {
3977 return 2;
3978 }
3979 if let Some(_) = self.language {
3980 return 1;
3981 }
3982 0
3983 }
3984 }
3985
3986 impl fidl::encoding::ValueTypeMarker for Information {
3987 type Borrowed<'a> = &'a Self;
3988 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3989 value
3990 }
3991 }
3992
3993 unsafe impl fidl::encoding::TypeMarker for Information {
3994 type Owned = Self;
3995
3996 #[inline(always)]
3997 fn inline_align(_context: fidl::encoding::Context) -> usize {
3998 8
3999 }
4000
4001 #[inline(always)]
4002 fn inline_size(_context: fidl::encoding::Context) -> usize {
4003 16
4004 }
4005 }
4006
4007 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Information, D>
4008 for &Information
4009 {
4010 unsafe fn encode(
4011 self,
4012 encoder: &mut fidl::encoding::Encoder<'_, D>,
4013 offset: usize,
4014 mut depth: fidl::encoding::Depth,
4015 ) -> fidl::Result<()> {
4016 encoder.debug_check_bounds::<Information>(offset);
4017 let max_ordinal: u64 = self.max_ordinal_present();
4019 encoder.write_num(max_ordinal, offset);
4020 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4021 if max_ordinal == 0 {
4023 return Ok(());
4024 }
4025 depth.increment()?;
4026 let envelope_size = 8;
4027 let bytes_len = max_ordinal as usize * envelope_size;
4028 #[allow(unused_variables)]
4029 let offset = encoder.out_of_line_offset(bytes_len);
4030 let mut _prev_end_offset: usize = 0;
4031 if 1 > max_ordinal {
4032 return Ok(());
4033 }
4034
4035 let cur_offset: usize = (1 - 1) * envelope_size;
4038
4039 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4041
4042 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2>, D>(
4047 self.language.as_ref().map(
4048 <fidl::encoding::BoundedString<2> as fidl::encoding::ValueTypeMarker>::borrow,
4049 ),
4050 encoder,
4051 offset + cur_offset,
4052 depth,
4053 )?;
4054
4055 _prev_end_offset = cur_offset + envelope_size;
4056 if 2 > max_ordinal {
4057 return Ok(());
4058 }
4059
4060 let cur_offset: usize = (2 - 1) * envelope_size;
4063
4064 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4066
4067 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4072 self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4073 encoder, offset + cur_offset, depth
4074 )?;
4075
4076 _prev_end_offset = cur_offset + envelope_size;
4077 if 3 > max_ordinal {
4078 return Ok(());
4079 }
4080
4081 let cur_offset: usize = (3 - 1) * envelope_size;
4084
4085 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4087
4088 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4093 self.description.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4094 encoder, offset + cur_offset, depth
4095 )?;
4096
4097 _prev_end_offset = cur_offset + envelope_size;
4098 if 4 > max_ordinal {
4099 return Ok(());
4100 }
4101
4102 let cur_offset: usize = (4 - 1) * envelope_size;
4105
4106 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4108
4109 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4114 self.provider.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4115 encoder, offset + cur_offset, depth
4116 )?;
4117
4118 _prev_end_offset = cur_offset + envelope_size;
4119
4120 Ok(())
4121 }
4122 }
4123
4124 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Information {
4125 #[inline(always)]
4126 fn new_empty() -> Self {
4127 Self::default()
4128 }
4129
4130 unsafe fn decode(
4131 &mut self,
4132 decoder: &mut fidl::encoding::Decoder<'_, D>,
4133 offset: usize,
4134 mut depth: fidl::encoding::Depth,
4135 ) -> fidl::Result<()> {
4136 decoder.debug_check_bounds::<Self>(offset);
4137 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4138 None => return Err(fidl::Error::NotNullable),
4139 Some(len) => len,
4140 };
4141 if len == 0 {
4143 return Ok(());
4144 };
4145 depth.increment()?;
4146 let envelope_size = 8;
4147 let bytes_len = len * envelope_size;
4148 let offset = decoder.out_of_line_offset(bytes_len)?;
4149 let mut _next_ordinal_to_read = 0;
4151 let mut next_offset = offset;
4152 let end_offset = offset + bytes_len;
4153 _next_ordinal_to_read += 1;
4154 if next_offset >= end_offset {
4155 return Ok(());
4156 }
4157
4158 while _next_ordinal_to_read < 1 {
4160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4161 _next_ordinal_to_read += 1;
4162 next_offset += envelope_size;
4163 }
4164
4165 let next_out_of_line = decoder.next_out_of_line();
4166 let handles_before = decoder.remaining_handles();
4167 if let Some((inlined, num_bytes, num_handles)) =
4168 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4169 {
4170 let member_inline_size =
4171 <fidl::encoding::BoundedString<2> as fidl::encoding::TypeMarker>::inline_size(
4172 decoder.context,
4173 );
4174 if inlined != (member_inline_size <= 4) {
4175 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4176 }
4177 let inner_offset;
4178 let mut inner_depth = depth.clone();
4179 if inlined {
4180 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4181 inner_offset = next_offset;
4182 } else {
4183 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4184 inner_depth.increment()?;
4185 }
4186 let val_ref = self
4187 .language
4188 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<2>, D));
4189 fidl::decode!(
4190 fidl::encoding::BoundedString<2>,
4191 D,
4192 val_ref,
4193 decoder,
4194 inner_offset,
4195 inner_depth
4196 )?;
4197 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4198 {
4199 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4200 }
4201 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4202 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4203 }
4204 }
4205
4206 next_offset += envelope_size;
4207 _next_ordinal_to_read += 1;
4208 if next_offset >= end_offset {
4209 return Ok(());
4210 }
4211
4212 while _next_ordinal_to_read < 2 {
4214 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4215 _next_ordinal_to_read += 1;
4216 next_offset += envelope_size;
4217 }
4218
4219 let next_out_of_line = decoder.next_out_of_line();
4220 let handles_before = decoder.remaining_handles();
4221 if let Some((inlined, num_bytes, num_handles)) =
4222 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4223 {
4224 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4225 if inlined != (member_inline_size <= 4) {
4226 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4227 }
4228 let inner_offset;
4229 let mut inner_depth = depth.clone();
4230 if inlined {
4231 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4232 inner_offset = next_offset;
4233 } else {
4234 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4235 inner_depth.increment()?;
4236 }
4237 let val_ref = self.name.get_or_insert_with(|| {
4238 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4239 });
4240 fidl::decode!(
4241 fidl::encoding::BoundedString<1024>,
4242 D,
4243 val_ref,
4244 decoder,
4245 inner_offset,
4246 inner_depth
4247 )?;
4248 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4249 {
4250 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4251 }
4252 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4253 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4254 }
4255 }
4256
4257 next_offset += envelope_size;
4258 _next_ordinal_to_read += 1;
4259 if next_offset >= end_offset {
4260 return Ok(());
4261 }
4262
4263 while _next_ordinal_to_read < 3 {
4265 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4266 _next_ordinal_to_read += 1;
4267 next_offset += envelope_size;
4268 }
4269
4270 let next_out_of_line = decoder.next_out_of_line();
4271 let handles_before = decoder.remaining_handles();
4272 if let Some((inlined, num_bytes, num_handles)) =
4273 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4274 {
4275 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4276 if inlined != (member_inline_size <= 4) {
4277 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4278 }
4279 let inner_offset;
4280 let mut inner_depth = depth.clone();
4281 if inlined {
4282 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4283 inner_offset = next_offset;
4284 } else {
4285 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4286 inner_depth.increment()?;
4287 }
4288 let val_ref = self.description.get_or_insert_with(|| {
4289 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4290 });
4291 fidl::decode!(
4292 fidl::encoding::BoundedString<1024>,
4293 D,
4294 val_ref,
4295 decoder,
4296 inner_offset,
4297 inner_depth
4298 )?;
4299 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4300 {
4301 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4302 }
4303 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4304 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4305 }
4306 }
4307
4308 next_offset += envelope_size;
4309 _next_ordinal_to_read += 1;
4310 if next_offset >= end_offset {
4311 return Ok(());
4312 }
4313
4314 while _next_ordinal_to_read < 4 {
4316 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4317 _next_ordinal_to_read += 1;
4318 next_offset += envelope_size;
4319 }
4320
4321 let next_out_of_line = decoder.next_out_of_line();
4322 let handles_before = decoder.remaining_handles();
4323 if let Some((inlined, num_bytes, num_handles)) =
4324 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4325 {
4326 let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4327 if inlined != (member_inline_size <= 4) {
4328 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4329 }
4330 let inner_offset;
4331 let mut inner_depth = depth.clone();
4332 if inlined {
4333 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4334 inner_offset = next_offset;
4335 } else {
4336 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4337 inner_depth.increment()?;
4338 }
4339 let val_ref = self.provider.get_or_insert_with(|| {
4340 fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4341 });
4342 fidl::decode!(
4343 fidl::encoding::BoundedString<1024>,
4344 D,
4345 val_ref,
4346 decoder,
4347 inner_offset,
4348 inner_depth
4349 )?;
4350 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4351 {
4352 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4353 }
4354 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4355 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4356 }
4357 }
4358
4359 next_offset += envelope_size;
4360
4361 while next_offset < end_offset {
4363 _next_ordinal_to_read += 1;
4364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4365 next_offset += envelope_size;
4366 }
4367
4368 Ok(())
4369 }
4370 }
4371
4372 impl L2capParameters {
4373 #[inline(always)]
4374 fn max_ordinal_present(&self) -> u64 {
4375 if let Some(_) = self.parameters {
4376 return 2;
4377 }
4378 if let Some(_) = self.psm {
4379 return 1;
4380 }
4381 0
4382 }
4383 }
4384
4385 impl fidl::encoding::ValueTypeMarker for L2capParameters {
4386 type Borrowed<'a> = &'a Self;
4387 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4388 value
4389 }
4390 }
4391
4392 unsafe impl fidl::encoding::TypeMarker for L2capParameters {
4393 type Owned = Self;
4394
4395 #[inline(always)]
4396 fn inline_align(_context: fidl::encoding::Context) -> usize {
4397 8
4398 }
4399
4400 #[inline(always)]
4401 fn inline_size(_context: fidl::encoding::Context) -> usize {
4402 16
4403 }
4404 }
4405
4406 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<L2capParameters, D>
4407 for &L2capParameters
4408 {
4409 unsafe fn encode(
4410 self,
4411 encoder: &mut fidl::encoding::Encoder<'_, D>,
4412 offset: usize,
4413 mut depth: fidl::encoding::Depth,
4414 ) -> fidl::Result<()> {
4415 encoder.debug_check_bounds::<L2capParameters>(offset);
4416 let max_ordinal: u64 = self.max_ordinal_present();
4418 encoder.write_num(max_ordinal, offset);
4419 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4420 if max_ordinal == 0 {
4422 return Ok(());
4423 }
4424 depth.increment()?;
4425 let envelope_size = 8;
4426 let bytes_len = max_ordinal as usize * envelope_size;
4427 #[allow(unused_variables)]
4428 let offset = encoder.out_of_line_offset(bytes_len);
4429 let mut _prev_end_offset: usize = 0;
4430 if 1 > max_ordinal {
4431 return Ok(());
4432 }
4433
4434 let cur_offset: usize = (1 - 1) * envelope_size;
4437
4438 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4440
4441 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4446 self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4447 encoder,
4448 offset + cur_offset,
4449 depth,
4450 )?;
4451
4452 _prev_end_offset = cur_offset + envelope_size;
4453 if 2 > max_ordinal {
4454 return Ok(());
4455 }
4456
4457 let cur_offset: usize = (2 - 1) * envelope_size;
4460
4461 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4463
4464 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::ChannelParameters, D>(
4469 self.parameters.as_ref().map(<fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::ValueTypeMarker>::borrow),
4470 encoder, offset + cur_offset, depth
4471 )?;
4472
4473 _prev_end_offset = cur_offset + envelope_size;
4474
4475 Ok(())
4476 }
4477 }
4478
4479 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for L2capParameters {
4480 #[inline(always)]
4481 fn new_empty() -> Self {
4482 Self::default()
4483 }
4484
4485 unsafe fn decode(
4486 &mut self,
4487 decoder: &mut fidl::encoding::Decoder<'_, D>,
4488 offset: usize,
4489 mut depth: fidl::encoding::Depth,
4490 ) -> fidl::Result<()> {
4491 decoder.debug_check_bounds::<Self>(offset);
4492 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4493 None => return Err(fidl::Error::NotNullable),
4494 Some(len) => len,
4495 };
4496 if len == 0 {
4498 return Ok(());
4499 };
4500 depth.increment()?;
4501 let envelope_size = 8;
4502 let bytes_len = len * envelope_size;
4503 let offset = decoder.out_of_line_offset(bytes_len)?;
4504 let mut _next_ordinal_to_read = 0;
4506 let mut next_offset = offset;
4507 let end_offset = offset + bytes_len;
4508 _next_ordinal_to_read += 1;
4509 if next_offset >= end_offset {
4510 return Ok(());
4511 }
4512
4513 while _next_ordinal_to_read < 1 {
4515 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4516 _next_ordinal_to_read += 1;
4517 next_offset += envelope_size;
4518 }
4519
4520 let next_out_of_line = decoder.next_out_of_line();
4521 let handles_before = decoder.remaining_handles();
4522 if let Some((inlined, num_bytes, num_handles)) =
4523 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4524 {
4525 let member_inline_size =
4526 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4527 if inlined != (member_inline_size <= 4) {
4528 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4529 }
4530 let inner_offset;
4531 let mut inner_depth = depth.clone();
4532 if inlined {
4533 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4534 inner_offset = next_offset;
4535 } else {
4536 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4537 inner_depth.increment()?;
4538 }
4539 let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
4540 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4541 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4542 {
4543 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4544 }
4545 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4546 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4547 }
4548 }
4549
4550 next_offset += envelope_size;
4551 _next_ordinal_to_read += 1;
4552 if next_offset >= end_offset {
4553 return Ok(());
4554 }
4555
4556 while _next_ordinal_to_read < 2 {
4558 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4559 _next_ordinal_to_read += 1;
4560 next_offset += envelope_size;
4561 }
4562
4563 let next_out_of_line = decoder.next_out_of_line();
4564 let handles_before = decoder.remaining_handles();
4565 if let Some((inlined, num_bytes, num_handles)) =
4566 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4567 {
4568 let member_inline_size = <fidl_fuchsia_bluetooth__common::ChannelParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4569 if inlined != (member_inline_size <= 4) {
4570 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4571 }
4572 let inner_offset;
4573 let mut inner_depth = depth.clone();
4574 if inlined {
4575 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4576 inner_offset = next_offset;
4577 } else {
4578 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4579 inner_depth.increment()?;
4580 }
4581 let val_ref = self.parameters.get_or_insert_with(|| {
4582 fidl::new_empty!(fidl_fuchsia_bluetooth__common::ChannelParameters, D)
4583 });
4584 fidl::decode!(
4585 fidl_fuchsia_bluetooth__common::ChannelParameters,
4586 D,
4587 val_ref,
4588 decoder,
4589 inner_offset,
4590 inner_depth
4591 )?;
4592 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4593 {
4594 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4595 }
4596 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4597 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4598 }
4599 }
4600
4601 next_offset += envelope_size;
4602
4603 while next_offset < end_offset {
4605 _next_ordinal_to_read += 1;
4606 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4607 next_offset += envelope_size;
4608 }
4609
4610 Ok(())
4611 }
4612 }
4613
4614 impl ProfileDescriptor {
4615 #[inline(always)]
4616 fn max_ordinal_present(&self) -> u64 {
4617 if let Some(_) = self.minor_version {
4618 return 3;
4619 }
4620 if let Some(_) = self.major_version {
4621 return 2;
4622 }
4623 if let Some(_) = self.profile_id {
4624 return 1;
4625 }
4626 0
4627 }
4628 }
4629
4630 impl fidl::encoding::ValueTypeMarker for ProfileDescriptor {
4631 type Borrowed<'a> = &'a Self;
4632 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4633 value
4634 }
4635 }
4636
4637 unsafe impl fidl::encoding::TypeMarker for ProfileDescriptor {
4638 type Owned = Self;
4639
4640 #[inline(always)]
4641 fn inline_align(_context: fidl::encoding::Context) -> usize {
4642 8
4643 }
4644
4645 #[inline(always)]
4646 fn inline_size(_context: fidl::encoding::Context) -> usize {
4647 16
4648 }
4649 }
4650
4651 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProfileDescriptor, D>
4652 for &ProfileDescriptor
4653 {
4654 unsafe fn encode(
4655 self,
4656 encoder: &mut fidl::encoding::Encoder<'_, D>,
4657 offset: usize,
4658 mut depth: fidl::encoding::Depth,
4659 ) -> fidl::Result<()> {
4660 encoder.debug_check_bounds::<ProfileDescriptor>(offset);
4661 let max_ordinal: u64 = self.max_ordinal_present();
4663 encoder.write_num(max_ordinal, offset);
4664 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4665 if max_ordinal == 0 {
4667 return Ok(());
4668 }
4669 depth.increment()?;
4670 let envelope_size = 8;
4671 let bytes_len = max_ordinal as usize * envelope_size;
4672 #[allow(unused_variables)]
4673 let offset = encoder.out_of_line_offset(bytes_len);
4674 let mut _prev_end_offset: usize = 0;
4675 if 1 > max_ordinal {
4676 return Ok(());
4677 }
4678
4679 let cur_offset: usize = (1 - 1) * envelope_size;
4682
4683 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4685
4686 fidl::encoding::encode_in_envelope_optional::<ServiceClassProfileIdentifier, D>(
4691 self.profile_id.as_ref().map(
4692 <ServiceClassProfileIdentifier as fidl::encoding::ValueTypeMarker>::borrow,
4693 ),
4694 encoder,
4695 offset + cur_offset,
4696 depth,
4697 )?;
4698
4699 _prev_end_offset = cur_offset + envelope_size;
4700 if 2 > max_ordinal {
4701 return Ok(());
4702 }
4703
4704 let cur_offset: usize = (2 - 1) * envelope_size;
4707
4708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4710
4711 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4716 self.major_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4717 encoder,
4718 offset + cur_offset,
4719 depth,
4720 )?;
4721
4722 _prev_end_offset = cur_offset + envelope_size;
4723 if 3 > max_ordinal {
4724 return Ok(());
4725 }
4726
4727 let cur_offset: usize = (3 - 1) * envelope_size;
4730
4731 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4733
4734 fidl::encoding::encode_in_envelope_optional::<u8, D>(
4739 self.minor_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4740 encoder,
4741 offset + cur_offset,
4742 depth,
4743 )?;
4744
4745 _prev_end_offset = cur_offset + envelope_size;
4746
4747 Ok(())
4748 }
4749 }
4750
4751 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProfileDescriptor {
4752 #[inline(always)]
4753 fn new_empty() -> Self {
4754 Self::default()
4755 }
4756
4757 unsafe fn decode(
4758 &mut self,
4759 decoder: &mut fidl::encoding::Decoder<'_, D>,
4760 offset: usize,
4761 mut depth: fidl::encoding::Depth,
4762 ) -> fidl::Result<()> {
4763 decoder.debug_check_bounds::<Self>(offset);
4764 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4765 None => return Err(fidl::Error::NotNullable),
4766 Some(len) => len,
4767 };
4768 if len == 0 {
4770 return Ok(());
4771 };
4772 depth.increment()?;
4773 let envelope_size = 8;
4774 let bytes_len = len * envelope_size;
4775 let offset = decoder.out_of_line_offset(bytes_len)?;
4776 let mut _next_ordinal_to_read = 0;
4778 let mut next_offset = offset;
4779 let end_offset = offset + bytes_len;
4780 _next_ordinal_to_read += 1;
4781 if next_offset >= end_offset {
4782 return Ok(());
4783 }
4784
4785 while _next_ordinal_to_read < 1 {
4787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4788 _next_ordinal_to_read += 1;
4789 next_offset += envelope_size;
4790 }
4791
4792 let next_out_of_line = decoder.next_out_of_line();
4793 let handles_before = decoder.remaining_handles();
4794 if let Some((inlined, num_bytes, num_handles)) =
4795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4796 {
4797 let member_inline_size =
4798 <ServiceClassProfileIdentifier as fidl::encoding::TypeMarker>::inline_size(
4799 decoder.context,
4800 );
4801 if inlined != (member_inline_size <= 4) {
4802 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4803 }
4804 let inner_offset;
4805 let mut inner_depth = depth.clone();
4806 if inlined {
4807 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4808 inner_offset = next_offset;
4809 } else {
4810 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4811 inner_depth.increment()?;
4812 }
4813 let val_ref = self
4814 .profile_id
4815 .get_or_insert_with(|| fidl::new_empty!(ServiceClassProfileIdentifier, D));
4816 fidl::decode!(
4817 ServiceClassProfileIdentifier,
4818 D,
4819 val_ref,
4820 decoder,
4821 inner_offset,
4822 inner_depth
4823 )?;
4824 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4825 {
4826 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4827 }
4828 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4829 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4830 }
4831 }
4832
4833 next_offset += envelope_size;
4834 _next_ordinal_to_read += 1;
4835 if next_offset >= end_offset {
4836 return Ok(());
4837 }
4838
4839 while _next_ordinal_to_read < 2 {
4841 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4842 _next_ordinal_to_read += 1;
4843 next_offset += envelope_size;
4844 }
4845
4846 let next_out_of_line = decoder.next_out_of_line();
4847 let handles_before = decoder.remaining_handles();
4848 if let Some((inlined, num_bytes, num_handles)) =
4849 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4850 {
4851 let member_inline_size =
4852 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4853 if inlined != (member_inline_size <= 4) {
4854 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4855 }
4856 let inner_offset;
4857 let mut inner_depth = depth.clone();
4858 if inlined {
4859 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4860 inner_offset = next_offset;
4861 } else {
4862 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4863 inner_depth.increment()?;
4864 }
4865 let val_ref = self.major_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4866 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4867 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4868 {
4869 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4870 }
4871 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4872 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4873 }
4874 }
4875
4876 next_offset += envelope_size;
4877 _next_ordinal_to_read += 1;
4878 if next_offset >= end_offset {
4879 return Ok(());
4880 }
4881
4882 while _next_ordinal_to_read < 3 {
4884 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4885 _next_ordinal_to_read += 1;
4886 next_offset += envelope_size;
4887 }
4888
4889 let next_out_of_line = decoder.next_out_of_line();
4890 let handles_before = decoder.remaining_handles();
4891 if let Some((inlined, num_bytes, num_handles)) =
4892 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4893 {
4894 let member_inline_size =
4895 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4896 if inlined != (member_inline_size <= 4) {
4897 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4898 }
4899 let inner_offset;
4900 let mut inner_depth = depth.clone();
4901 if inlined {
4902 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4903 inner_offset = next_offset;
4904 } else {
4905 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4906 inner_depth.increment()?;
4907 }
4908 let val_ref = self.minor_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4909 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4910 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4911 {
4912 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4913 }
4914 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4915 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4916 }
4917 }
4918
4919 next_offset += envelope_size;
4920
4921 while next_offset < end_offset {
4923 _next_ordinal_to_read += 1;
4924 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4925 next_offset += envelope_size;
4926 }
4927
4928 Ok(())
4929 }
4930 }
4931
4932 impl ProfileAdvertiseResponse {
4933 #[inline(always)]
4934 fn max_ordinal_present(&self) -> u64 {
4935 if let Some(_) = self.services {
4936 return 1;
4937 }
4938 0
4939 }
4940 }
4941
4942 impl fidl::encoding::ValueTypeMarker for ProfileAdvertiseResponse {
4943 type Borrowed<'a> = &'a Self;
4944 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4945 value
4946 }
4947 }
4948
4949 unsafe impl fidl::encoding::TypeMarker for ProfileAdvertiseResponse {
4950 type Owned = Self;
4951
4952 #[inline(always)]
4953 fn inline_align(_context: fidl::encoding::Context) -> usize {
4954 8
4955 }
4956
4957 #[inline(always)]
4958 fn inline_size(_context: fidl::encoding::Context) -> usize {
4959 16
4960 }
4961 }
4962
4963 unsafe impl<D: fidl::encoding::ResourceDialect>
4964 fidl::encoding::Encode<ProfileAdvertiseResponse, D> for &ProfileAdvertiseResponse
4965 {
4966 unsafe fn encode(
4967 self,
4968 encoder: &mut fidl::encoding::Encoder<'_, D>,
4969 offset: usize,
4970 mut depth: fidl::encoding::Depth,
4971 ) -> fidl::Result<()> {
4972 encoder.debug_check_bounds::<ProfileAdvertiseResponse>(offset);
4973 let max_ordinal: u64 = self.max_ordinal_present();
4975 encoder.write_num(max_ordinal, offset);
4976 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4977 if max_ordinal == 0 {
4979 return Ok(());
4980 }
4981 depth.increment()?;
4982 let envelope_size = 8;
4983 let bytes_len = max_ordinal as usize * envelope_size;
4984 #[allow(unused_variables)]
4985 let offset = encoder.out_of_line_offset(bytes_len);
4986 let mut _prev_end_offset: usize = 0;
4987 if 1 > max_ordinal {
4988 return Ok(());
4989 }
4990
4991 let cur_offset: usize = (1 - 1) * envelope_size;
4994
4995 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4997
4998 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ServiceDefinition, 32>, D>(
5003 self.services.as_ref().map(<fidl::encoding::Vector<ServiceDefinition, 32> as fidl::encoding::ValueTypeMarker>::borrow),
5004 encoder, offset + cur_offset, depth
5005 )?;
5006
5007 _prev_end_offset = cur_offset + envelope_size;
5008
5009 Ok(())
5010 }
5011 }
5012
5013 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5014 for ProfileAdvertiseResponse
5015 {
5016 #[inline(always)]
5017 fn new_empty() -> Self {
5018 Self::default()
5019 }
5020
5021 unsafe fn decode(
5022 &mut self,
5023 decoder: &mut fidl::encoding::Decoder<'_, D>,
5024 offset: usize,
5025 mut depth: fidl::encoding::Depth,
5026 ) -> fidl::Result<()> {
5027 decoder.debug_check_bounds::<Self>(offset);
5028 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5029 None => return Err(fidl::Error::NotNullable),
5030 Some(len) => len,
5031 };
5032 if len == 0 {
5034 return Ok(());
5035 };
5036 depth.increment()?;
5037 let envelope_size = 8;
5038 let bytes_len = len * envelope_size;
5039 let offset = decoder.out_of_line_offset(bytes_len)?;
5040 let mut _next_ordinal_to_read = 0;
5042 let mut next_offset = offset;
5043 let end_offset = offset + bytes_len;
5044 _next_ordinal_to_read += 1;
5045 if next_offset >= end_offset {
5046 return Ok(());
5047 }
5048
5049 while _next_ordinal_to_read < 1 {
5051 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5052 _next_ordinal_to_read += 1;
5053 next_offset += envelope_size;
5054 }
5055
5056 let next_out_of_line = decoder.next_out_of_line();
5057 let handles_before = decoder.remaining_handles();
5058 if let Some((inlined, num_bytes, num_handles)) =
5059 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5060 {
5061 let member_inline_size = <fidl::encoding::Vector<ServiceDefinition, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5062 if inlined != (member_inline_size <= 4) {
5063 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5064 }
5065 let inner_offset;
5066 let mut inner_depth = depth.clone();
5067 if inlined {
5068 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5069 inner_offset = next_offset;
5070 } else {
5071 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5072 inner_depth.increment()?;
5073 }
5074 let val_ref = self.services.get_or_insert_with(
5075 || fidl::new_empty!(fidl::encoding::Vector<ServiceDefinition, 32>, D),
5076 );
5077 fidl::decode!(fidl::encoding::Vector<ServiceDefinition, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5079 {
5080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5081 }
5082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5084 }
5085 }
5086
5087 next_offset += envelope_size;
5088
5089 while next_offset < end_offset {
5091 _next_ordinal_to_read += 1;
5092 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5093 next_offset += envelope_size;
5094 }
5095
5096 Ok(())
5097 }
5098 }
5099
5100 impl ProtocolDescriptor {
5101 #[inline(always)]
5102 fn max_ordinal_present(&self) -> u64 {
5103 if let Some(_) = self.params {
5104 return 2;
5105 }
5106 if let Some(_) = self.protocol {
5107 return 1;
5108 }
5109 0
5110 }
5111 }
5112
5113 impl fidl::encoding::ValueTypeMarker for ProtocolDescriptor {
5114 type Borrowed<'a> = &'a Self;
5115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5116 value
5117 }
5118 }
5119
5120 unsafe impl fidl::encoding::TypeMarker for ProtocolDescriptor {
5121 type Owned = Self;
5122
5123 #[inline(always)]
5124 fn inline_align(_context: fidl::encoding::Context) -> usize {
5125 8
5126 }
5127
5128 #[inline(always)]
5129 fn inline_size(_context: fidl::encoding::Context) -> usize {
5130 16
5131 }
5132 }
5133
5134 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProtocolDescriptor, D>
5135 for &ProtocolDescriptor
5136 {
5137 unsafe fn encode(
5138 self,
5139 encoder: &mut fidl::encoding::Encoder<'_, D>,
5140 offset: usize,
5141 mut depth: fidl::encoding::Depth,
5142 ) -> fidl::Result<()> {
5143 encoder.debug_check_bounds::<ProtocolDescriptor>(offset);
5144 let max_ordinal: u64 = self.max_ordinal_present();
5146 encoder.write_num(max_ordinal, offset);
5147 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5148 if max_ordinal == 0 {
5150 return Ok(());
5151 }
5152 depth.increment()?;
5153 let envelope_size = 8;
5154 let bytes_len = max_ordinal as usize * envelope_size;
5155 #[allow(unused_variables)]
5156 let offset = encoder.out_of_line_offset(bytes_len);
5157 let mut _prev_end_offset: usize = 0;
5158 if 1 > max_ordinal {
5159 return Ok(());
5160 }
5161
5162 let cur_offset: usize = (1 - 1) * envelope_size;
5165
5166 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5168
5169 fidl::encoding::encode_in_envelope_optional::<ProtocolIdentifier, D>(
5174 self.protocol
5175 .as_ref()
5176 .map(<ProtocolIdentifier as fidl::encoding::ValueTypeMarker>::borrow),
5177 encoder,
5178 offset + cur_offset,
5179 depth,
5180 )?;
5181
5182 _prev_end_offset = cur_offset + envelope_size;
5183 if 2 > max_ordinal {
5184 return Ok(());
5185 }
5186
5187 let cur_offset: usize = (2 - 1) * envelope_size;
5190
5191 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5193
5194 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DataElement, 255>, D>(
5199 self.params.as_ref().map(<fidl::encoding::Vector<DataElement, 255> as fidl::encoding::ValueTypeMarker>::borrow),
5200 encoder, offset + cur_offset, depth
5201 )?;
5202
5203 _prev_end_offset = cur_offset + envelope_size;
5204
5205 Ok(())
5206 }
5207 }
5208
5209 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProtocolDescriptor {
5210 #[inline(always)]
5211 fn new_empty() -> Self {
5212 Self::default()
5213 }
5214
5215 unsafe fn decode(
5216 &mut self,
5217 decoder: &mut fidl::encoding::Decoder<'_, D>,
5218 offset: usize,
5219 mut depth: fidl::encoding::Depth,
5220 ) -> fidl::Result<()> {
5221 decoder.debug_check_bounds::<Self>(offset);
5222 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5223 None => return Err(fidl::Error::NotNullable),
5224 Some(len) => len,
5225 };
5226 if len == 0 {
5228 return Ok(());
5229 };
5230 depth.increment()?;
5231 let envelope_size = 8;
5232 let bytes_len = len * envelope_size;
5233 let offset = decoder.out_of_line_offset(bytes_len)?;
5234 let mut _next_ordinal_to_read = 0;
5236 let mut next_offset = offset;
5237 let end_offset = offset + bytes_len;
5238 _next_ordinal_to_read += 1;
5239 if next_offset >= end_offset {
5240 return Ok(());
5241 }
5242
5243 while _next_ordinal_to_read < 1 {
5245 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5246 _next_ordinal_to_read += 1;
5247 next_offset += envelope_size;
5248 }
5249
5250 let next_out_of_line = decoder.next_out_of_line();
5251 let handles_before = decoder.remaining_handles();
5252 if let Some((inlined, num_bytes, num_handles)) =
5253 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5254 {
5255 let member_inline_size =
5256 <ProtocolIdentifier as fidl::encoding::TypeMarker>::inline_size(
5257 decoder.context,
5258 );
5259 if inlined != (member_inline_size <= 4) {
5260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5261 }
5262 let inner_offset;
5263 let mut inner_depth = depth.clone();
5264 if inlined {
5265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5266 inner_offset = next_offset;
5267 } else {
5268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5269 inner_depth.increment()?;
5270 }
5271 let val_ref =
5272 self.protocol.get_or_insert_with(|| fidl::new_empty!(ProtocolIdentifier, D));
5273 fidl::decode!(ProtocolIdentifier, D, val_ref, decoder, inner_offset, inner_depth)?;
5274 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5275 {
5276 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5277 }
5278 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5279 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5280 }
5281 }
5282
5283 next_offset += envelope_size;
5284 _next_ordinal_to_read += 1;
5285 if next_offset >= end_offset {
5286 return Ok(());
5287 }
5288
5289 while _next_ordinal_to_read < 2 {
5291 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5292 _next_ordinal_to_read += 1;
5293 next_offset += envelope_size;
5294 }
5295
5296 let next_out_of_line = decoder.next_out_of_line();
5297 let handles_before = decoder.remaining_handles();
5298 if let Some((inlined, num_bytes, num_handles)) =
5299 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5300 {
5301 let member_inline_size = <fidl::encoding::Vector<DataElement, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5302 if inlined != (member_inline_size <= 4) {
5303 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5304 }
5305 let inner_offset;
5306 let mut inner_depth = depth.clone();
5307 if inlined {
5308 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5309 inner_offset = next_offset;
5310 } else {
5311 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5312 inner_depth.increment()?;
5313 }
5314 let val_ref = self.params.get_or_insert_with(
5315 || fidl::new_empty!(fidl::encoding::Vector<DataElement, 255>, D),
5316 );
5317 fidl::decode!(fidl::encoding::Vector<DataElement, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
5318 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5319 {
5320 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5321 }
5322 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5323 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5324 }
5325 }
5326
5327 next_offset += envelope_size;
5328
5329 while next_offset < end_offset {
5331 _next_ordinal_to_read += 1;
5332 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5333 next_offset += envelope_size;
5334 }
5335
5336 Ok(())
5337 }
5338 }
5339
5340 impl RfcommParameters {
5341 #[inline(always)]
5342 fn max_ordinal_present(&self) -> u64 {
5343 if let Some(_) = self.channel {
5344 return 1;
5345 }
5346 0
5347 }
5348 }
5349
5350 impl fidl::encoding::ValueTypeMarker for RfcommParameters {
5351 type Borrowed<'a> = &'a Self;
5352 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5353 value
5354 }
5355 }
5356
5357 unsafe impl fidl::encoding::TypeMarker for RfcommParameters {
5358 type Owned = Self;
5359
5360 #[inline(always)]
5361 fn inline_align(_context: fidl::encoding::Context) -> usize {
5362 8
5363 }
5364
5365 #[inline(always)]
5366 fn inline_size(_context: fidl::encoding::Context) -> usize {
5367 16
5368 }
5369 }
5370
5371 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RfcommParameters, D>
5372 for &RfcommParameters
5373 {
5374 unsafe fn encode(
5375 self,
5376 encoder: &mut fidl::encoding::Encoder<'_, D>,
5377 offset: usize,
5378 mut depth: fidl::encoding::Depth,
5379 ) -> fidl::Result<()> {
5380 encoder.debug_check_bounds::<RfcommParameters>(offset);
5381 let max_ordinal: u64 = self.max_ordinal_present();
5383 encoder.write_num(max_ordinal, offset);
5384 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5385 if max_ordinal == 0 {
5387 return Ok(());
5388 }
5389 depth.increment()?;
5390 let envelope_size = 8;
5391 let bytes_len = max_ordinal as usize * envelope_size;
5392 #[allow(unused_variables)]
5393 let offset = encoder.out_of_line_offset(bytes_len);
5394 let mut _prev_end_offset: usize = 0;
5395 if 1 > max_ordinal {
5396 return Ok(());
5397 }
5398
5399 let cur_offset: usize = (1 - 1) * envelope_size;
5402
5403 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5405
5406 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5411 self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5412 encoder,
5413 offset + cur_offset,
5414 depth,
5415 )?;
5416
5417 _prev_end_offset = cur_offset + envelope_size;
5418
5419 Ok(())
5420 }
5421 }
5422
5423 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RfcommParameters {
5424 #[inline(always)]
5425 fn new_empty() -> Self {
5426 Self::default()
5427 }
5428
5429 unsafe fn decode(
5430 &mut self,
5431 decoder: &mut fidl::encoding::Decoder<'_, D>,
5432 offset: usize,
5433 mut depth: fidl::encoding::Depth,
5434 ) -> fidl::Result<()> {
5435 decoder.debug_check_bounds::<Self>(offset);
5436 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5437 None => return Err(fidl::Error::NotNullable),
5438 Some(len) => len,
5439 };
5440 if len == 0 {
5442 return Ok(());
5443 };
5444 depth.increment()?;
5445 let envelope_size = 8;
5446 let bytes_len = len * envelope_size;
5447 let offset = decoder.out_of_line_offset(bytes_len)?;
5448 let mut _next_ordinal_to_read = 0;
5450 let mut next_offset = offset;
5451 let end_offset = offset + bytes_len;
5452 _next_ordinal_to_read += 1;
5453 if next_offset >= end_offset {
5454 return Ok(());
5455 }
5456
5457 while _next_ordinal_to_read < 1 {
5459 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5460 _next_ordinal_to_read += 1;
5461 next_offset += envelope_size;
5462 }
5463
5464 let next_out_of_line = decoder.next_out_of_line();
5465 let handles_before = decoder.remaining_handles();
5466 if let Some((inlined, num_bytes, num_handles)) =
5467 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5468 {
5469 let member_inline_size =
5470 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5471 if inlined != (member_inline_size <= 4) {
5472 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5473 }
5474 let inner_offset;
5475 let mut inner_depth = depth.clone();
5476 if inlined {
5477 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5478 inner_offset = next_offset;
5479 } else {
5480 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5481 inner_depth.increment()?;
5482 }
5483 let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
5484 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5485 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5486 {
5487 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5488 }
5489 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5490 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5491 }
5492 }
5493
5494 next_offset += envelope_size;
5495
5496 while next_offset < end_offset {
5498 _next_ordinal_to_read += 1;
5499 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5500 next_offset += envelope_size;
5501 }
5502
5503 Ok(())
5504 }
5505 }
5506
5507 impl ScoConnectionParameters {
5508 #[inline(always)]
5509 fn max_ordinal_present(&self) -> u64 {
5510 if let Some(_) = self.max_tx_data_size {
5511 return 10;
5512 }
5513 if let Some(_) = self.path {
5514 return 9;
5515 }
5516 if let Some(_) = self.io_pcm_sample_payload_msb_position {
5517 return 8;
5518 }
5519 if let Some(_) = self.io_pcm_data_format {
5520 return 7;
5521 }
5522 if let Some(_) = self.io_frame_size {
5523 return 6;
5524 }
5525 if let Some(_) = self.io_coding_format {
5526 return 5;
5527 }
5528 if let Some(_) = self.io_bandwidth {
5529 return 4;
5530 }
5531 if let Some(_) = self.air_frame_size {
5532 return 3;
5533 }
5534 if let Some(_) = self.air_coding_format {
5535 return 2;
5536 }
5537 if let Some(_) = self.parameter_set {
5538 return 1;
5539 }
5540 0
5541 }
5542 }
5543
5544 impl fidl::encoding::ValueTypeMarker for ScoConnectionParameters {
5545 type Borrowed<'a> = &'a Self;
5546 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5547 value
5548 }
5549 }
5550
5551 unsafe impl fidl::encoding::TypeMarker for ScoConnectionParameters {
5552 type Owned = Self;
5553
5554 #[inline(always)]
5555 fn inline_align(_context: fidl::encoding::Context) -> usize {
5556 8
5557 }
5558
5559 #[inline(always)]
5560 fn inline_size(_context: fidl::encoding::Context) -> usize {
5561 16
5562 }
5563 }
5564
5565 unsafe impl<D: fidl::encoding::ResourceDialect>
5566 fidl::encoding::Encode<ScoConnectionParameters, D> for &ScoConnectionParameters
5567 {
5568 unsafe fn encode(
5569 self,
5570 encoder: &mut fidl::encoding::Encoder<'_, D>,
5571 offset: usize,
5572 mut depth: fidl::encoding::Depth,
5573 ) -> fidl::Result<()> {
5574 encoder.debug_check_bounds::<ScoConnectionParameters>(offset);
5575 let max_ordinal: u64 = self.max_ordinal_present();
5577 encoder.write_num(max_ordinal, offset);
5578 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5579 if max_ordinal == 0 {
5581 return Ok(());
5582 }
5583 depth.increment()?;
5584 let envelope_size = 8;
5585 let bytes_len = max_ordinal as usize * envelope_size;
5586 #[allow(unused_variables)]
5587 let offset = encoder.out_of_line_offset(bytes_len);
5588 let mut _prev_end_offset: usize = 0;
5589 if 1 > max_ordinal {
5590 return Ok(());
5591 }
5592
5593 let cur_offset: usize = (1 - 1) * envelope_size;
5596
5597 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5599
5600 fidl::encoding::encode_in_envelope_optional::<HfpParameterSet, D>(
5605 self.parameter_set
5606 .as_ref()
5607 .map(<HfpParameterSet as fidl::encoding::ValueTypeMarker>::borrow),
5608 encoder,
5609 offset + cur_offset,
5610 depth,
5611 )?;
5612
5613 _prev_end_offset = cur_offset + envelope_size;
5614 if 2 > max_ordinal {
5615 return Ok(());
5616 }
5617
5618 let cur_offset: usize = (2 - 1) * envelope_size;
5621
5622 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5624
5625 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D>(
5630 self.air_coding_format.as_ref().map(<fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::ValueTypeMarker>::borrow),
5631 encoder, offset + cur_offset, depth
5632 )?;
5633
5634 _prev_end_offset = cur_offset + envelope_size;
5635 if 3 > max_ordinal {
5636 return Ok(());
5637 }
5638
5639 let cur_offset: usize = (3 - 1) * envelope_size;
5642
5643 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5645
5646 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5651 self.air_frame_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5652 encoder,
5653 offset + cur_offset,
5654 depth,
5655 )?;
5656
5657 _prev_end_offset = cur_offset + envelope_size;
5658 if 4 > max_ordinal {
5659 return Ok(());
5660 }
5661
5662 let cur_offset: usize = (4 - 1) * envelope_size;
5665
5666 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5668
5669 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5674 self.io_bandwidth.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5675 encoder,
5676 offset + cur_offset,
5677 depth,
5678 )?;
5679
5680 _prev_end_offset = cur_offset + envelope_size;
5681 if 5 > max_ordinal {
5682 return Ok(());
5683 }
5684
5685 let cur_offset: usize = (5 - 1) * envelope_size;
5688
5689 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5691
5692 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D>(
5697 self.io_coding_format.as_ref().map(<fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::ValueTypeMarker>::borrow),
5698 encoder, offset + cur_offset, depth
5699 )?;
5700
5701 _prev_end_offset = cur_offset + envelope_size;
5702 if 6 > max_ordinal {
5703 return Ok(());
5704 }
5705
5706 let cur_offset: usize = (6 - 1) * envelope_size;
5709
5710 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5712
5713 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5718 self.io_frame_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5719 encoder,
5720 offset + cur_offset,
5721 depth,
5722 )?;
5723
5724 _prev_end_offset = cur_offset + envelope_size;
5725 if 7 > max_ordinal {
5726 return Ok(());
5727 }
5728
5729 let cur_offset: usize = (7 - 1) * envelope_size;
5732
5733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5735
5736 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::SampleFormat, D>(
5741 self.io_pcm_data_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::SampleFormat as fidl::encoding::ValueTypeMarker>::borrow),
5742 encoder, offset + cur_offset, depth
5743 )?;
5744
5745 _prev_end_offset = cur_offset + envelope_size;
5746 if 8 > max_ordinal {
5747 return Ok(());
5748 }
5749
5750 let cur_offset: usize = (8 - 1) * envelope_size;
5753
5754 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5756
5757 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5762 self.io_pcm_sample_payload_msb_position
5763 .as_ref()
5764 .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5765 encoder,
5766 offset + cur_offset,
5767 depth,
5768 )?;
5769
5770 _prev_end_offset = cur_offset + envelope_size;
5771 if 9 > max_ordinal {
5772 return Ok(());
5773 }
5774
5775 let cur_offset: usize = (9 - 1) * envelope_size;
5778
5779 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5781
5782 fidl::encoding::encode_in_envelope_optional::<DataPath, D>(
5787 self.path.as_ref().map(<DataPath as fidl::encoding::ValueTypeMarker>::borrow),
5788 encoder,
5789 offset + cur_offset,
5790 depth,
5791 )?;
5792
5793 _prev_end_offset = cur_offset + envelope_size;
5794 if 10 > max_ordinal {
5795 return Ok(());
5796 }
5797
5798 let cur_offset: usize = (10 - 1) * envelope_size;
5801
5802 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5804
5805 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5810 self.max_tx_data_size
5811 .as_ref()
5812 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5813 encoder,
5814 offset + cur_offset,
5815 depth,
5816 )?;
5817
5818 _prev_end_offset = cur_offset + envelope_size;
5819
5820 Ok(())
5821 }
5822 }
5823
5824 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5825 for ScoConnectionParameters
5826 {
5827 #[inline(always)]
5828 fn new_empty() -> Self {
5829 Self::default()
5830 }
5831
5832 unsafe fn decode(
5833 &mut self,
5834 decoder: &mut fidl::encoding::Decoder<'_, D>,
5835 offset: usize,
5836 mut depth: fidl::encoding::Depth,
5837 ) -> fidl::Result<()> {
5838 decoder.debug_check_bounds::<Self>(offset);
5839 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5840 None => return Err(fidl::Error::NotNullable),
5841 Some(len) => len,
5842 };
5843 if len == 0 {
5845 return Ok(());
5846 };
5847 depth.increment()?;
5848 let envelope_size = 8;
5849 let bytes_len = len * envelope_size;
5850 let offset = decoder.out_of_line_offset(bytes_len)?;
5851 let mut _next_ordinal_to_read = 0;
5853 let mut next_offset = offset;
5854 let end_offset = offset + bytes_len;
5855 _next_ordinal_to_read += 1;
5856 if next_offset >= end_offset {
5857 return Ok(());
5858 }
5859
5860 while _next_ordinal_to_read < 1 {
5862 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5863 _next_ordinal_to_read += 1;
5864 next_offset += envelope_size;
5865 }
5866
5867 let next_out_of_line = decoder.next_out_of_line();
5868 let handles_before = decoder.remaining_handles();
5869 if let Some((inlined, num_bytes, num_handles)) =
5870 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5871 {
5872 let member_inline_size =
5873 <HfpParameterSet as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5874 if inlined != (member_inline_size <= 4) {
5875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5876 }
5877 let inner_offset;
5878 let mut inner_depth = depth.clone();
5879 if inlined {
5880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5881 inner_offset = next_offset;
5882 } else {
5883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5884 inner_depth.increment()?;
5885 }
5886 let val_ref =
5887 self.parameter_set.get_or_insert_with(|| fidl::new_empty!(HfpParameterSet, D));
5888 fidl::decode!(HfpParameterSet, D, val_ref, decoder, inner_offset, inner_depth)?;
5889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5890 {
5891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5892 }
5893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5895 }
5896 }
5897
5898 next_offset += envelope_size;
5899 _next_ordinal_to_read += 1;
5900 if next_offset >= end_offset {
5901 return Ok(());
5902 }
5903
5904 while _next_ordinal_to_read < 2 {
5906 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5907 _next_ordinal_to_read += 1;
5908 next_offset += envelope_size;
5909 }
5910
5911 let next_out_of_line = decoder.next_out_of_line();
5912 let handles_before = decoder.remaining_handles();
5913 if let Some((inlined, num_bytes, num_handles)) =
5914 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5915 {
5916 let member_inline_size = <fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5917 if inlined != (member_inline_size <= 4) {
5918 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5919 }
5920 let inner_offset;
5921 let mut inner_depth = depth.clone();
5922 if inlined {
5923 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5924 inner_offset = next_offset;
5925 } else {
5926 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5927 inner_depth.increment()?;
5928 }
5929 let val_ref = self.air_coding_format.get_or_insert_with(|| {
5930 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D)
5931 });
5932 fidl::decode!(
5933 fidl_fuchsia_bluetooth__common::AssignedCodingFormat,
5934 D,
5935 val_ref,
5936 decoder,
5937 inner_offset,
5938 inner_depth
5939 )?;
5940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5941 {
5942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5943 }
5944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5946 }
5947 }
5948
5949 next_offset += envelope_size;
5950 _next_ordinal_to_read += 1;
5951 if next_offset >= end_offset {
5952 return Ok(());
5953 }
5954
5955 while _next_ordinal_to_read < 3 {
5957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5958 _next_ordinal_to_read += 1;
5959 next_offset += envelope_size;
5960 }
5961
5962 let next_out_of_line = decoder.next_out_of_line();
5963 let handles_before = decoder.remaining_handles();
5964 if let Some((inlined, num_bytes, num_handles)) =
5965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5966 {
5967 let member_inline_size =
5968 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5969 if inlined != (member_inline_size <= 4) {
5970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5971 }
5972 let inner_offset;
5973 let mut inner_depth = depth.clone();
5974 if inlined {
5975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5976 inner_offset = next_offset;
5977 } else {
5978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5979 inner_depth.increment()?;
5980 }
5981 let val_ref = self.air_frame_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
5982 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5983 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5984 {
5985 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5986 }
5987 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5988 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5989 }
5990 }
5991
5992 next_offset += envelope_size;
5993 _next_ordinal_to_read += 1;
5994 if next_offset >= end_offset {
5995 return Ok(());
5996 }
5997
5998 while _next_ordinal_to_read < 4 {
6000 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6001 _next_ordinal_to_read += 1;
6002 next_offset += envelope_size;
6003 }
6004
6005 let next_out_of_line = decoder.next_out_of_line();
6006 let handles_before = decoder.remaining_handles();
6007 if let Some((inlined, num_bytes, num_handles)) =
6008 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6009 {
6010 let member_inline_size =
6011 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6012 if inlined != (member_inline_size <= 4) {
6013 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6014 }
6015 let inner_offset;
6016 let mut inner_depth = depth.clone();
6017 if inlined {
6018 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6019 inner_offset = next_offset;
6020 } else {
6021 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6022 inner_depth.increment()?;
6023 }
6024 let val_ref = self.io_bandwidth.get_or_insert_with(|| fidl::new_empty!(u32, D));
6025 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6026 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6027 {
6028 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6029 }
6030 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6031 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6032 }
6033 }
6034
6035 next_offset += envelope_size;
6036 _next_ordinal_to_read += 1;
6037 if next_offset >= end_offset {
6038 return Ok(());
6039 }
6040
6041 while _next_ordinal_to_read < 5 {
6043 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6044 _next_ordinal_to_read += 1;
6045 next_offset += envelope_size;
6046 }
6047
6048 let next_out_of_line = decoder.next_out_of_line();
6049 let handles_before = decoder.remaining_handles();
6050 if let Some((inlined, num_bytes, num_handles)) =
6051 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6052 {
6053 let member_inline_size = <fidl_fuchsia_bluetooth__common::AssignedCodingFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6054 if inlined != (member_inline_size <= 4) {
6055 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6056 }
6057 let inner_offset;
6058 let mut inner_depth = depth.clone();
6059 if inlined {
6060 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6061 inner_offset = next_offset;
6062 } else {
6063 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6064 inner_depth.increment()?;
6065 }
6066 let val_ref = self.io_coding_format.get_or_insert_with(|| {
6067 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AssignedCodingFormat, D)
6068 });
6069 fidl::decode!(
6070 fidl_fuchsia_bluetooth__common::AssignedCodingFormat,
6071 D,
6072 val_ref,
6073 decoder,
6074 inner_offset,
6075 inner_depth
6076 )?;
6077 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6078 {
6079 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6080 }
6081 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6082 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6083 }
6084 }
6085
6086 next_offset += envelope_size;
6087 _next_ordinal_to_read += 1;
6088 if next_offset >= end_offset {
6089 return Ok(());
6090 }
6091
6092 while _next_ordinal_to_read < 6 {
6094 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6095 _next_ordinal_to_read += 1;
6096 next_offset += envelope_size;
6097 }
6098
6099 let next_out_of_line = decoder.next_out_of_line();
6100 let handles_before = decoder.remaining_handles();
6101 if let Some((inlined, num_bytes, num_handles)) =
6102 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6103 {
6104 let member_inline_size =
6105 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6106 if inlined != (member_inline_size <= 4) {
6107 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6108 }
6109 let inner_offset;
6110 let mut inner_depth = depth.clone();
6111 if inlined {
6112 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6113 inner_offset = next_offset;
6114 } else {
6115 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6116 inner_depth.increment()?;
6117 }
6118 let val_ref = self.io_frame_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
6119 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6120 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6121 {
6122 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6123 }
6124 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6125 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6126 }
6127 }
6128
6129 next_offset += envelope_size;
6130 _next_ordinal_to_read += 1;
6131 if next_offset >= end_offset {
6132 return Ok(());
6133 }
6134
6135 while _next_ordinal_to_read < 7 {
6137 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6138 _next_ordinal_to_read += 1;
6139 next_offset += envelope_size;
6140 }
6141
6142 let next_out_of_line = decoder.next_out_of_line();
6143 let handles_before = decoder.remaining_handles();
6144 if let Some((inlined, num_bytes, num_handles)) =
6145 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6146 {
6147 let member_inline_size = <fidl_fuchsia_hardware_audio__common::SampleFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6148 if inlined != (member_inline_size <= 4) {
6149 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6150 }
6151 let inner_offset;
6152 let mut inner_depth = depth.clone();
6153 if inlined {
6154 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6155 inner_offset = next_offset;
6156 } else {
6157 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6158 inner_depth.increment()?;
6159 }
6160 let val_ref = self.io_pcm_data_format.get_or_insert_with(|| {
6161 fidl::new_empty!(fidl_fuchsia_hardware_audio__common::SampleFormat, D)
6162 });
6163 fidl::decode!(
6164 fidl_fuchsia_hardware_audio__common::SampleFormat,
6165 D,
6166 val_ref,
6167 decoder,
6168 inner_offset,
6169 inner_depth
6170 )?;
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 < 8 {
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 <u8 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
6213 .io_pcm_sample_payload_msb_position
6214 .get_or_insert_with(|| fidl::new_empty!(u8, D));
6215 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6216 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6217 {
6218 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6219 }
6220 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6221 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6222 }
6223 }
6224
6225 next_offset += envelope_size;
6226 _next_ordinal_to_read += 1;
6227 if next_offset >= end_offset {
6228 return Ok(());
6229 }
6230
6231 while _next_ordinal_to_read < 9 {
6233 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6234 _next_ordinal_to_read += 1;
6235 next_offset += envelope_size;
6236 }
6237
6238 let next_out_of_line = decoder.next_out_of_line();
6239 let handles_before = decoder.remaining_handles();
6240 if let Some((inlined, num_bytes, num_handles)) =
6241 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6242 {
6243 let member_inline_size =
6244 <DataPath as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6245 if inlined != (member_inline_size <= 4) {
6246 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6247 }
6248 let inner_offset;
6249 let mut inner_depth = depth.clone();
6250 if inlined {
6251 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6252 inner_offset = next_offset;
6253 } else {
6254 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6255 inner_depth.increment()?;
6256 }
6257 let val_ref = self.path.get_or_insert_with(|| fidl::new_empty!(DataPath, D));
6258 fidl::decode!(DataPath, D, val_ref, decoder, inner_offset, inner_depth)?;
6259 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6260 {
6261 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6262 }
6263 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6264 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6265 }
6266 }
6267
6268 next_offset += envelope_size;
6269 _next_ordinal_to_read += 1;
6270 if next_offset >= end_offset {
6271 return Ok(());
6272 }
6273
6274 while _next_ordinal_to_read < 10 {
6276 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6277 _next_ordinal_to_read += 1;
6278 next_offset += envelope_size;
6279 }
6280
6281 let next_out_of_line = decoder.next_out_of_line();
6282 let handles_before = decoder.remaining_handles();
6283 if let Some((inlined, num_bytes, num_handles)) =
6284 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6285 {
6286 let member_inline_size =
6287 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6288 if inlined != (member_inline_size <= 4) {
6289 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6290 }
6291 let inner_offset;
6292 let mut inner_depth = depth.clone();
6293 if inlined {
6294 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6295 inner_offset = next_offset;
6296 } else {
6297 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6298 inner_depth.increment()?;
6299 }
6300 let val_ref = self.max_tx_data_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
6301 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6302 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6303 {
6304 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6305 }
6306 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6307 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6308 }
6309 }
6310
6311 next_offset += envelope_size;
6312
6313 while next_offset < end_offset {
6315 _next_ordinal_to_read += 1;
6316 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6317 next_offset += envelope_size;
6318 }
6319
6320 Ok(())
6321 }
6322 }
6323
6324 impl ScoConnectionWriteRequest {
6325 #[inline(always)]
6326 fn max_ordinal_present(&self) -> u64 {
6327 if let Some(_) = self.data {
6328 return 1;
6329 }
6330 0
6331 }
6332 }
6333
6334 impl fidl::encoding::ValueTypeMarker for ScoConnectionWriteRequest {
6335 type Borrowed<'a> = &'a Self;
6336 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6337 value
6338 }
6339 }
6340
6341 unsafe impl fidl::encoding::TypeMarker for ScoConnectionWriteRequest {
6342 type Owned = Self;
6343
6344 #[inline(always)]
6345 fn inline_align(_context: fidl::encoding::Context) -> usize {
6346 8
6347 }
6348
6349 #[inline(always)]
6350 fn inline_size(_context: fidl::encoding::Context) -> usize {
6351 16
6352 }
6353 }
6354
6355 unsafe impl<D: fidl::encoding::ResourceDialect>
6356 fidl::encoding::Encode<ScoConnectionWriteRequest, D> for &ScoConnectionWriteRequest
6357 {
6358 unsafe fn encode(
6359 self,
6360 encoder: &mut fidl::encoding::Encoder<'_, D>,
6361 offset: usize,
6362 mut depth: fidl::encoding::Depth,
6363 ) -> fidl::Result<()> {
6364 encoder.debug_check_bounds::<ScoConnectionWriteRequest>(offset);
6365 let max_ordinal: u64 = self.max_ordinal_present();
6367 encoder.write_num(max_ordinal, offset);
6368 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6369 if max_ordinal == 0 {
6371 return Ok(());
6372 }
6373 depth.increment()?;
6374 let envelope_size = 8;
6375 let bytes_len = max_ordinal as usize * envelope_size;
6376 #[allow(unused_variables)]
6377 let offset = encoder.out_of_line_offset(bytes_len);
6378 let mut _prev_end_offset: usize = 0;
6379 if 1 > max_ordinal {
6380 return Ok(());
6381 }
6382
6383 let cur_offset: usize = (1 - 1) * envelope_size;
6386
6387 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6389
6390 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6395 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6396 encoder, offset + cur_offset, depth
6397 )?;
6398
6399 _prev_end_offset = cur_offset + envelope_size;
6400
6401 Ok(())
6402 }
6403 }
6404
6405 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6406 for ScoConnectionWriteRequest
6407 {
6408 #[inline(always)]
6409 fn new_empty() -> Self {
6410 Self::default()
6411 }
6412
6413 unsafe fn decode(
6414 &mut self,
6415 decoder: &mut fidl::encoding::Decoder<'_, D>,
6416 offset: usize,
6417 mut depth: fidl::encoding::Depth,
6418 ) -> fidl::Result<()> {
6419 decoder.debug_check_bounds::<Self>(offset);
6420 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6421 None => return Err(fidl::Error::NotNullable),
6422 Some(len) => len,
6423 };
6424 if len == 0 {
6426 return Ok(());
6427 };
6428 depth.increment()?;
6429 let envelope_size = 8;
6430 let bytes_len = len * envelope_size;
6431 let offset = decoder.out_of_line_offset(bytes_len)?;
6432 let mut _next_ordinal_to_read = 0;
6434 let mut next_offset = offset;
6435 let end_offset = offset + bytes_len;
6436 _next_ordinal_to_read += 1;
6437 if next_offset >= end_offset {
6438 return Ok(());
6439 }
6440
6441 while _next_ordinal_to_read < 1 {
6443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6444 _next_ordinal_to_read += 1;
6445 next_offset += envelope_size;
6446 }
6447
6448 let next_out_of_line = decoder.next_out_of_line();
6449 let handles_before = decoder.remaining_handles();
6450 if let Some((inlined, num_bytes, num_handles)) =
6451 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6452 {
6453 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6454 if inlined != (member_inline_size <= 4) {
6455 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6456 }
6457 let inner_offset;
6458 let mut inner_depth = depth.clone();
6459 if inlined {
6460 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6461 inner_offset = next_offset;
6462 } else {
6463 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6464 inner_depth.increment()?;
6465 }
6466 let val_ref = self.data.get_or_insert_with(|| {
6467 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6468 });
6469 fidl::decode!(
6470 fidl::encoding::UnboundedVector<u8>,
6471 D,
6472 val_ref,
6473 decoder,
6474 inner_offset,
6475 inner_depth
6476 )?;
6477 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6478 {
6479 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6480 }
6481 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6482 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6483 }
6484 }
6485
6486 next_offset += envelope_size;
6487
6488 while next_offset < end_offset {
6490 _next_ordinal_to_read += 1;
6491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6492 next_offset += envelope_size;
6493 }
6494
6495 Ok(())
6496 }
6497 }
6498
6499 impl ScoConnectionReadResponse {
6500 #[inline(always)]
6501 fn max_ordinal_present(&self) -> u64 {
6502 if let Some(_) = self.data {
6503 return 2;
6504 }
6505 if let Some(_) = self.status_flag {
6506 return 1;
6507 }
6508 0
6509 }
6510 }
6511
6512 impl fidl::encoding::ValueTypeMarker for ScoConnectionReadResponse {
6513 type Borrowed<'a> = &'a Self;
6514 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6515 value
6516 }
6517 }
6518
6519 unsafe impl fidl::encoding::TypeMarker for ScoConnectionReadResponse {
6520 type Owned = Self;
6521
6522 #[inline(always)]
6523 fn inline_align(_context: fidl::encoding::Context) -> usize {
6524 8
6525 }
6526
6527 #[inline(always)]
6528 fn inline_size(_context: fidl::encoding::Context) -> usize {
6529 16
6530 }
6531 }
6532
6533 unsafe impl<D: fidl::encoding::ResourceDialect>
6534 fidl::encoding::Encode<ScoConnectionReadResponse, D> for &ScoConnectionReadResponse
6535 {
6536 unsafe fn encode(
6537 self,
6538 encoder: &mut fidl::encoding::Encoder<'_, D>,
6539 offset: usize,
6540 mut depth: fidl::encoding::Depth,
6541 ) -> fidl::Result<()> {
6542 encoder.debug_check_bounds::<ScoConnectionReadResponse>(offset);
6543 let max_ordinal: u64 = self.max_ordinal_present();
6545 encoder.write_num(max_ordinal, offset);
6546 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6547 if max_ordinal == 0 {
6549 return Ok(());
6550 }
6551 depth.increment()?;
6552 let envelope_size = 8;
6553 let bytes_len = max_ordinal as usize * envelope_size;
6554 #[allow(unused_variables)]
6555 let offset = encoder.out_of_line_offset(bytes_len);
6556 let mut _prev_end_offset: usize = 0;
6557 if 1 > max_ordinal {
6558 return Ok(());
6559 }
6560
6561 let cur_offset: usize = (1 - 1) * envelope_size;
6564
6565 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6567
6568 fidl::encoding::encode_in_envelope_optional::<RxPacketStatus, D>(
6573 self.status_flag
6574 .as_ref()
6575 .map(<RxPacketStatus as fidl::encoding::ValueTypeMarker>::borrow),
6576 encoder,
6577 offset + cur_offset,
6578 depth,
6579 )?;
6580
6581 _prev_end_offset = cur_offset + envelope_size;
6582 if 2 > max_ordinal {
6583 return Ok(());
6584 }
6585
6586 let cur_offset: usize = (2 - 1) * envelope_size;
6589
6590 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6592
6593 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6598 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6599 encoder, offset + cur_offset, depth
6600 )?;
6601
6602 _prev_end_offset = cur_offset + envelope_size;
6603
6604 Ok(())
6605 }
6606 }
6607
6608 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6609 for ScoConnectionReadResponse
6610 {
6611 #[inline(always)]
6612 fn new_empty() -> Self {
6613 Self::default()
6614 }
6615
6616 unsafe fn decode(
6617 &mut self,
6618 decoder: &mut fidl::encoding::Decoder<'_, D>,
6619 offset: usize,
6620 mut depth: fidl::encoding::Depth,
6621 ) -> fidl::Result<()> {
6622 decoder.debug_check_bounds::<Self>(offset);
6623 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6624 None => return Err(fidl::Error::NotNullable),
6625 Some(len) => len,
6626 };
6627 if len == 0 {
6629 return Ok(());
6630 };
6631 depth.increment()?;
6632 let envelope_size = 8;
6633 let bytes_len = len * envelope_size;
6634 let offset = decoder.out_of_line_offset(bytes_len)?;
6635 let mut _next_ordinal_to_read = 0;
6637 let mut next_offset = offset;
6638 let end_offset = offset + bytes_len;
6639 _next_ordinal_to_read += 1;
6640 if next_offset >= end_offset {
6641 return Ok(());
6642 }
6643
6644 while _next_ordinal_to_read < 1 {
6646 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6647 _next_ordinal_to_read += 1;
6648 next_offset += envelope_size;
6649 }
6650
6651 let next_out_of_line = decoder.next_out_of_line();
6652 let handles_before = decoder.remaining_handles();
6653 if let Some((inlined, num_bytes, num_handles)) =
6654 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6655 {
6656 let member_inline_size =
6657 <RxPacketStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6658 if inlined != (member_inline_size <= 4) {
6659 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6660 }
6661 let inner_offset;
6662 let mut inner_depth = depth.clone();
6663 if inlined {
6664 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6665 inner_offset = next_offset;
6666 } else {
6667 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6668 inner_depth.increment()?;
6669 }
6670 let val_ref =
6671 self.status_flag.get_or_insert_with(|| fidl::new_empty!(RxPacketStatus, D));
6672 fidl::decode!(RxPacketStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
6673 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6674 {
6675 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6676 }
6677 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6678 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6679 }
6680 }
6681
6682 next_offset += envelope_size;
6683 _next_ordinal_to_read += 1;
6684 if next_offset >= end_offset {
6685 return Ok(());
6686 }
6687
6688 while _next_ordinal_to_read < 2 {
6690 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6691 _next_ordinal_to_read += 1;
6692 next_offset += envelope_size;
6693 }
6694
6695 let next_out_of_line = decoder.next_out_of_line();
6696 let handles_before = decoder.remaining_handles();
6697 if let Some((inlined, num_bytes, num_handles)) =
6698 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6699 {
6700 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6701 if inlined != (member_inline_size <= 4) {
6702 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6703 }
6704 let inner_offset;
6705 let mut inner_depth = depth.clone();
6706 if inlined {
6707 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6708 inner_offset = next_offset;
6709 } else {
6710 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6711 inner_depth.increment()?;
6712 }
6713 let val_ref = self.data.get_or_insert_with(|| {
6714 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6715 });
6716 fidl::decode!(
6717 fidl::encoding::UnboundedVector<u8>,
6718 D,
6719 val_ref,
6720 decoder,
6721 inner_offset,
6722 inner_depth
6723 )?;
6724 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6725 {
6726 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6727 }
6728 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6729 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6730 }
6731 }
6732
6733 next_offset += envelope_size;
6734
6735 while next_offset < end_offset {
6737 _next_ordinal_to_read += 1;
6738 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6739 next_offset += envelope_size;
6740 }
6741
6742 Ok(())
6743 }
6744 }
6745
6746 impl ServiceDefinition {
6747 #[inline(always)]
6748 fn max_ordinal_present(&self) -> u64 {
6749 if let Some(_) = self.additional_attributes {
6750 return 6;
6751 }
6752 if let Some(_) = self.information {
6753 return 5;
6754 }
6755 if let Some(_) = self.profile_descriptors {
6756 return 4;
6757 }
6758 if let Some(_) = self.additional_protocol_descriptor_lists {
6759 return 3;
6760 }
6761 if let Some(_) = self.protocol_descriptor_list {
6762 return 2;
6763 }
6764 if let Some(_) = self.service_class_uuids {
6765 return 1;
6766 }
6767 0
6768 }
6769 }
6770
6771 impl fidl::encoding::ValueTypeMarker for ServiceDefinition {
6772 type Borrowed<'a> = &'a Self;
6773 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6774 value
6775 }
6776 }
6777
6778 unsafe impl fidl::encoding::TypeMarker for ServiceDefinition {
6779 type Owned = Self;
6780
6781 #[inline(always)]
6782 fn inline_align(_context: fidl::encoding::Context) -> usize {
6783 8
6784 }
6785
6786 #[inline(always)]
6787 fn inline_size(_context: fidl::encoding::Context) -> usize {
6788 16
6789 }
6790 }
6791
6792 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDefinition, D>
6793 for &ServiceDefinition
6794 {
6795 unsafe fn encode(
6796 self,
6797 encoder: &mut fidl::encoding::Encoder<'_, D>,
6798 offset: usize,
6799 mut depth: fidl::encoding::Depth,
6800 ) -> fidl::Result<()> {
6801 encoder.debug_check_bounds::<ServiceDefinition>(offset);
6802 let max_ordinal: u64 = self.max_ordinal_present();
6804 encoder.write_num(max_ordinal, offset);
6805 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6806 if max_ordinal == 0 {
6808 return Ok(());
6809 }
6810 depth.increment()?;
6811 let envelope_size = 8;
6812 let bytes_len = max_ordinal as usize * envelope_size;
6813 #[allow(unused_variables)]
6814 let offset = encoder.out_of_line_offset(bytes_len);
6815 let mut _prev_end_offset: usize = 0;
6816 if 1 > max_ordinal {
6817 return Ok(());
6818 }
6819
6820 let cur_offset: usize = (1 - 1) * envelope_size;
6823
6824 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6826
6827 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D>(
6832 self.service_class_uuids.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6833 encoder, offset + cur_offset, depth
6834 )?;
6835
6836 _prev_end_offset = cur_offset + envelope_size;
6837 if 2 > max_ordinal {
6838 return Ok(());
6839 }
6840
6841 let cur_offset: usize = (2 - 1) * envelope_size;
6844
6845 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6847
6848 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProtocolDescriptor, 255>, D>(
6853 self.protocol_descriptor_list.as_ref().map(<fidl::encoding::Vector<ProtocolDescriptor, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6854 encoder, offset + cur_offset, depth
6855 )?;
6856
6857 _prev_end_offset = cur_offset + envelope_size;
6858 if 3 > max_ordinal {
6859 return Ok(());
6860 }
6861
6862 let cur_offset: usize = (3 - 1) * envelope_size;
6865
6866 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6868
6869 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255>, D>(
6874 self.additional_protocol_descriptor_lists.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6875 encoder, offset + cur_offset, depth
6876 )?;
6877
6878 _prev_end_offset = cur_offset + envelope_size;
6879 if 4 > max_ordinal {
6880 return Ok(());
6881 }
6882
6883 let cur_offset: usize = (4 - 1) * envelope_size;
6886
6887 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6889
6890 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ProfileDescriptor, 255>, D>(
6895 self.profile_descriptors.as_ref().map(<fidl::encoding::Vector<ProfileDescriptor, 255> as fidl::encoding::ValueTypeMarker>::borrow),
6896 encoder, offset + cur_offset, depth
6897 )?;
6898
6899 _prev_end_offset = cur_offset + envelope_size;
6900 if 5 > max_ordinal {
6901 return Ok(());
6902 }
6903
6904 let cur_offset: usize = (5 - 1) * envelope_size;
6907
6908 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6910
6911 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Information, 85>, D>(
6916 self.information.as_ref().map(<fidl::encoding::Vector<Information, 85> as fidl::encoding::ValueTypeMarker>::borrow),
6917 encoder, offset + cur_offset, depth
6918 )?;
6919
6920 _prev_end_offset = cur_offset + envelope_size;
6921 if 6 > max_ordinal {
6922 return Ok(());
6923 }
6924
6925 let cur_offset: usize = (6 - 1) * envelope_size;
6928
6929 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6931
6932 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Attribute, 65023>, D>(
6937 self.additional_attributes.as_ref().map(<fidl::encoding::Vector<Attribute, 65023> as fidl::encoding::ValueTypeMarker>::borrow),
6938 encoder, offset + cur_offset, depth
6939 )?;
6940
6941 _prev_end_offset = cur_offset + envelope_size;
6942
6943 Ok(())
6944 }
6945 }
6946
6947 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDefinition {
6948 #[inline(always)]
6949 fn new_empty() -> Self {
6950 Self::default()
6951 }
6952
6953 unsafe fn decode(
6954 &mut self,
6955 decoder: &mut fidl::encoding::Decoder<'_, D>,
6956 offset: usize,
6957 mut depth: fidl::encoding::Depth,
6958 ) -> fidl::Result<()> {
6959 decoder.debug_check_bounds::<Self>(offset);
6960 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6961 None => return Err(fidl::Error::NotNullable),
6962 Some(len) => len,
6963 };
6964 if len == 0 {
6966 return Ok(());
6967 };
6968 depth.increment()?;
6969 let envelope_size = 8;
6970 let bytes_len = len * envelope_size;
6971 let offset = decoder.out_of_line_offset(bytes_len)?;
6972 let mut _next_ordinal_to_read = 0;
6974 let mut next_offset = offset;
6975 let end_offset = offset + bytes_len;
6976 _next_ordinal_to_read += 1;
6977 if next_offset >= end_offset {
6978 return Ok(());
6979 }
6980
6981 while _next_ordinal_to_read < 1 {
6983 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6984 _next_ordinal_to_read += 1;
6985 next_offset += envelope_size;
6986 }
6987
6988 let next_out_of_line = decoder.next_out_of_line();
6989 let handles_before = decoder.remaining_handles();
6990 if let Some((inlined, num_bytes, num_handles)) =
6991 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6992 {
6993 let member_inline_size = <fidl::encoding::Vector<
6994 fidl_fuchsia_bluetooth__common::Uuid,
6995 255,
6996 > as fidl::encoding::TypeMarker>::inline_size(
6997 decoder.context
6998 );
6999 if inlined != (member_inline_size <= 4) {
7000 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7001 }
7002 let inner_offset;
7003 let mut inner_depth = depth.clone();
7004 if inlined {
7005 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7006 inner_offset = next_offset;
7007 } else {
7008 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7009 inner_depth.increment()?;
7010 }
7011 let val_ref =
7012 self.service_class_uuids.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D));
7013 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7014 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7015 {
7016 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7017 }
7018 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7019 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7020 }
7021 }
7022
7023 next_offset += envelope_size;
7024 _next_ordinal_to_read += 1;
7025 if next_offset >= end_offset {
7026 return Ok(());
7027 }
7028
7029 while _next_ordinal_to_read < 2 {
7031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7032 _next_ordinal_to_read += 1;
7033 next_offset += envelope_size;
7034 }
7035
7036 let next_out_of_line = decoder.next_out_of_line();
7037 let handles_before = decoder.remaining_handles();
7038 if let Some((inlined, num_bytes, num_handles)) =
7039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7040 {
7041 let member_inline_size = <fidl::encoding::Vector<ProtocolDescriptor, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7042 if inlined != (member_inline_size <= 4) {
7043 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7044 }
7045 let inner_offset;
7046 let mut inner_depth = depth.clone();
7047 if inlined {
7048 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7049 inner_offset = next_offset;
7050 } else {
7051 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7052 inner_depth.increment()?;
7053 }
7054 let val_ref = self.protocol_descriptor_list.get_or_insert_with(
7055 || fidl::new_empty!(fidl::encoding::Vector<ProtocolDescriptor, 255>, D),
7056 );
7057 fidl::decode!(fidl::encoding::Vector<ProtocolDescriptor, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7058 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7059 {
7060 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7061 }
7062 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7063 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7064 }
7065 }
7066
7067 next_offset += envelope_size;
7068 _next_ordinal_to_read += 1;
7069 if next_offset >= end_offset {
7070 return Ok(());
7071 }
7072
7073 while _next_ordinal_to_read < 3 {
7075 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7076 _next_ordinal_to_read += 1;
7077 next_offset += envelope_size;
7078 }
7079
7080 let next_out_of_line = decoder.next_out_of_line();
7081 let handles_before = decoder.remaining_handles();
7082 if let Some((inlined, num_bytes, num_handles)) =
7083 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7084 {
7085 let member_inline_size = <fidl::encoding::Vector<
7086 fidl::encoding::Vector<ProtocolDescriptor, 255>,
7087 255,
7088 > as fidl::encoding::TypeMarker>::inline_size(
7089 decoder.context
7090 );
7091 if inlined != (member_inline_size <= 4) {
7092 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7093 }
7094 let inner_offset;
7095 let mut inner_depth = depth.clone();
7096 if inlined {
7097 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7098 inner_offset = next_offset;
7099 } else {
7100 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7101 inner_depth.increment()?;
7102 }
7103 let val_ref = self.additional_protocol_descriptor_lists.get_or_insert_with(|| {
7104 fidl::new_empty!(
7105 fidl::encoding::Vector<
7106 fidl::encoding::Vector<ProtocolDescriptor, 255>,
7107 255,
7108 >,
7109 D
7110 )
7111 });
7112 fidl::decode!(
7113 fidl::encoding::Vector<fidl::encoding::Vector<ProtocolDescriptor, 255>, 255>,
7114 D,
7115 val_ref,
7116 decoder,
7117 inner_offset,
7118 inner_depth
7119 )?;
7120 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7121 {
7122 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7123 }
7124 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7125 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7126 }
7127 }
7128
7129 next_offset += envelope_size;
7130 _next_ordinal_to_read += 1;
7131 if next_offset >= end_offset {
7132 return Ok(());
7133 }
7134
7135 while _next_ordinal_to_read < 4 {
7137 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7138 _next_ordinal_to_read += 1;
7139 next_offset += envelope_size;
7140 }
7141
7142 let next_out_of_line = decoder.next_out_of_line();
7143 let handles_before = decoder.remaining_handles();
7144 if let Some((inlined, num_bytes, num_handles)) =
7145 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7146 {
7147 let member_inline_size = <fidl::encoding::Vector<ProfileDescriptor, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7148 if inlined != (member_inline_size <= 4) {
7149 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7150 }
7151 let inner_offset;
7152 let mut inner_depth = depth.clone();
7153 if inlined {
7154 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7155 inner_offset = next_offset;
7156 } else {
7157 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7158 inner_depth.increment()?;
7159 }
7160 let val_ref = self.profile_descriptors.get_or_insert_with(
7161 || fidl::new_empty!(fidl::encoding::Vector<ProfileDescriptor, 255>, D),
7162 );
7163 fidl::decode!(fidl::encoding::Vector<ProfileDescriptor, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7164 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7165 {
7166 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7167 }
7168 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7169 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7170 }
7171 }
7172
7173 next_offset += envelope_size;
7174 _next_ordinal_to_read += 1;
7175 if next_offset >= end_offset {
7176 return Ok(());
7177 }
7178
7179 while _next_ordinal_to_read < 5 {
7181 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7182 _next_ordinal_to_read += 1;
7183 next_offset += envelope_size;
7184 }
7185
7186 let next_out_of_line = decoder.next_out_of_line();
7187 let handles_before = decoder.remaining_handles();
7188 if let Some((inlined, num_bytes, num_handles)) =
7189 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7190 {
7191 let member_inline_size = <fidl::encoding::Vector<Information, 85> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7192 if inlined != (member_inline_size <= 4) {
7193 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7194 }
7195 let inner_offset;
7196 let mut inner_depth = depth.clone();
7197 if inlined {
7198 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7199 inner_offset = next_offset;
7200 } else {
7201 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7202 inner_depth.increment()?;
7203 }
7204 let val_ref = self.information.get_or_insert_with(
7205 || fidl::new_empty!(fidl::encoding::Vector<Information, 85>, D),
7206 );
7207 fidl::decode!(fidl::encoding::Vector<Information, 85>, D, val_ref, decoder, inner_offset, inner_depth)?;
7208 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7209 {
7210 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7211 }
7212 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7213 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7214 }
7215 }
7216
7217 next_offset += envelope_size;
7218 _next_ordinal_to_read += 1;
7219 if next_offset >= end_offset {
7220 return Ok(());
7221 }
7222
7223 while _next_ordinal_to_read < 6 {
7225 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7226 _next_ordinal_to_read += 1;
7227 next_offset += envelope_size;
7228 }
7229
7230 let next_out_of_line = decoder.next_out_of_line();
7231 let handles_before = decoder.remaining_handles();
7232 if let Some((inlined, num_bytes, num_handles)) =
7233 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7234 {
7235 let member_inline_size = <fidl::encoding::Vector<Attribute, 65023> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7236 if inlined != (member_inline_size <= 4) {
7237 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7238 }
7239 let inner_offset;
7240 let mut inner_depth = depth.clone();
7241 if inlined {
7242 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7243 inner_offset = next_offset;
7244 } else {
7245 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7246 inner_depth.increment()?;
7247 }
7248 let val_ref = self.additional_attributes.get_or_insert_with(
7249 || fidl::new_empty!(fidl::encoding::Vector<Attribute, 65023>, D),
7250 );
7251 fidl::decode!(fidl::encoding::Vector<Attribute, 65023>, D, val_ref, decoder, inner_offset, inner_depth)?;
7252 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7253 {
7254 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7255 }
7256 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7257 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7258 }
7259 }
7260
7261 next_offset += envelope_size;
7262
7263 while next_offset < end_offset {
7265 _next_ordinal_to_read += 1;
7266 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7267 next_offset += envelope_size;
7268 }
7269
7270 Ok(())
7271 }
7272 }
7273
7274 impl fidl::encoding::ValueTypeMarker for AudioEncoderSettings {
7275 type Borrowed<'a> = &'a Self;
7276 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7277 value
7278 }
7279 }
7280
7281 unsafe impl fidl::encoding::TypeMarker for AudioEncoderSettings {
7282 type Owned = Self;
7283
7284 #[inline(always)]
7285 fn inline_align(_context: fidl::encoding::Context) -> usize {
7286 8
7287 }
7288
7289 #[inline(always)]
7290 fn inline_size(_context: fidl::encoding::Context) -> usize {
7291 16
7292 }
7293 }
7294
7295 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioEncoderSettings, D>
7296 for &AudioEncoderSettings
7297 {
7298 #[inline]
7299 unsafe fn encode(
7300 self,
7301 encoder: &mut fidl::encoding::Encoder<'_, D>,
7302 offset: usize,
7303 _depth: fidl::encoding::Depth,
7304 ) -> fidl::Result<()> {
7305 encoder.debug_check_bounds::<AudioEncoderSettings>(offset);
7306 encoder.write_num::<u64>(self.ordinal(), offset);
7307 match self {
7308 AudioEncoderSettings::Sbc(ref val) => {
7309 fidl::encoding::encode_in_envelope::<fidl_fuchsia_media__common::SbcEncoderSettings, D>(
7310 <fidl_fuchsia_media__common::SbcEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
7311 encoder, offset + 8, _depth
7312 )
7313 }
7314 AudioEncoderSettings::Aac(ref val) => {
7315 fidl::encoding::encode_in_envelope::<fidl_fuchsia_media__common::AacEncoderSettings, D>(
7316 <fidl_fuchsia_media__common::AacEncoderSettings as fidl::encoding::ValueTypeMarker>::borrow(val),
7317 encoder, offset + 8, _depth
7318 )
7319 }
7320 AudioEncoderSettings::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7321 }
7322 }
7323 }
7324
7325 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioEncoderSettings {
7326 #[inline(always)]
7327 fn new_empty() -> Self {
7328 Self::__SourceBreaking { unknown_ordinal: 0 }
7329 }
7330
7331 #[inline]
7332 unsafe fn decode(
7333 &mut self,
7334 decoder: &mut fidl::encoding::Decoder<'_, D>,
7335 offset: usize,
7336 mut depth: fidl::encoding::Depth,
7337 ) -> fidl::Result<()> {
7338 decoder.debug_check_bounds::<Self>(offset);
7339 #[allow(unused_variables)]
7340 let next_out_of_line = decoder.next_out_of_line();
7341 let handles_before = decoder.remaining_handles();
7342 let (ordinal, inlined, num_bytes, num_handles) =
7343 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7344
7345 let member_inline_size = match ordinal {
7346 1 => <fidl_fuchsia_media__common::SbcEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7347 2 => <fidl_fuchsia_media__common::AacEncoderSettings as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7348 0 => return Err(fidl::Error::UnknownUnionTag),
7349 _ => num_bytes as usize,
7350 };
7351
7352 if inlined != (member_inline_size <= 4) {
7353 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7354 }
7355 let _inner_offset;
7356 if inlined {
7357 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7358 _inner_offset = offset + 8;
7359 } else {
7360 depth.increment()?;
7361 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7362 }
7363 match ordinal {
7364 1 => {
7365 #[allow(irrefutable_let_patterns)]
7366 if let AudioEncoderSettings::Sbc(_) = self {
7367 } else {
7369 *self = AudioEncoderSettings::Sbc(fidl::new_empty!(
7371 fidl_fuchsia_media__common::SbcEncoderSettings,
7372 D
7373 ));
7374 }
7375 #[allow(irrefutable_let_patterns)]
7376 if let AudioEncoderSettings::Sbc(ref mut val) = self {
7377 fidl::decode!(
7378 fidl_fuchsia_media__common::SbcEncoderSettings,
7379 D,
7380 val,
7381 decoder,
7382 _inner_offset,
7383 depth
7384 )?;
7385 } else {
7386 unreachable!()
7387 }
7388 }
7389 2 => {
7390 #[allow(irrefutable_let_patterns)]
7391 if let AudioEncoderSettings::Aac(_) = self {
7392 } else {
7394 *self = AudioEncoderSettings::Aac(fidl::new_empty!(
7396 fidl_fuchsia_media__common::AacEncoderSettings,
7397 D
7398 ));
7399 }
7400 #[allow(irrefutable_let_patterns)]
7401 if let AudioEncoderSettings::Aac(ref mut val) = self {
7402 fidl::decode!(
7403 fidl_fuchsia_media__common::AacEncoderSettings,
7404 D,
7405 val,
7406 decoder,
7407 _inner_offset,
7408 depth
7409 )?;
7410 } else {
7411 unreachable!()
7412 }
7413 }
7414 #[allow(deprecated)]
7415 ordinal => {
7416 for _ in 0..num_handles {
7417 decoder.drop_next_handle()?;
7418 }
7419 *self = AudioEncoderSettings::__SourceBreaking { unknown_ordinal: ordinal };
7420 }
7421 }
7422 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7423 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7424 }
7425 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7426 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7427 }
7428 Ok(())
7429 }
7430 }
7431
7432 impl fidl::encoding::ValueTypeMarker for AudioOffloadFeatures {
7433 type Borrowed<'a> = &'a Self;
7434 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7435 value
7436 }
7437 }
7438
7439 unsafe impl fidl::encoding::TypeMarker for AudioOffloadFeatures {
7440 type Owned = Self;
7441
7442 #[inline(always)]
7443 fn inline_align(_context: fidl::encoding::Context) -> usize {
7444 8
7445 }
7446
7447 #[inline(always)]
7448 fn inline_size(_context: fidl::encoding::Context) -> usize {
7449 16
7450 }
7451 }
7452
7453 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AudioOffloadFeatures, D>
7454 for &AudioOffloadFeatures
7455 {
7456 #[inline]
7457 unsafe fn encode(
7458 self,
7459 encoder: &mut fidl::encoding::Encoder<'_, D>,
7460 offset: usize,
7461 _depth: fidl::encoding::Depth,
7462 ) -> fidl::Result<()> {
7463 encoder.debug_check_bounds::<AudioOffloadFeatures>(offset);
7464 encoder.write_num::<u64>(self.ordinal(), offset);
7465 match self {
7466 AudioOffloadFeatures::Sbc(ref val) => {
7467 fidl::encoding::encode_in_envelope::<AudioSbcSupport, D>(
7468 <AudioSbcSupport as fidl::encoding::ValueTypeMarker>::borrow(val),
7469 encoder,
7470 offset + 8,
7471 _depth,
7472 )
7473 }
7474 AudioOffloadFeatures::Aac(ref val) => {
7475 fidl::encoding::encode_in_envelope::<AudioAacSupport, D>(
7476 <AudioAacSupport as fidl::encoding::ValueTypeMarker>::borrow(val),
7477 encoder,
7478 offset + 8,
7479 _depth,
7480 )
7481 }
7482 AudioOffloadFeatures::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7483 }
7484 }
7485 }
7486
7487 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AudioOffloadFeatures {
7488 #[inline(always)]
7489 fn new_empty() -> Self {
7490 Self::__SourceBreaking { unknown_ordinal: 0 }
7491 }
7492
7493 #[inline]
7494 unsafe fn decode(
7495 &mut self,
7496 decoder: &mut fidl::encoding::Decoder<'_, D>,
7497 offset: usize,
7498 mut depth: fidl::encoding::Depth,
7499 ) -> fidl::Result<()> {
7500 decoder.debug_check_bounds::<Self>(offset);
7501 #[allow(unused_variables)]
7502 let next_out_of_line = decoder.next_out_of_line();
7503 let handles_before = decoder.remaining_handles();
7504 let (ordinal, inlined, num_bytes, num_handles) =
7505 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7506
7507 let member_inline_size = match ordinal {
7508 1 => <AudioSbcSupport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7509 2 => <AudioAacSupport as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7510 0 => return Err(fidl::Error::UnknownUnionTag),
7511 _ => num_bytes as usize,
7512 };
7513
7514 if inlined != (member_inline_size <= 4) {
7515 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7516 }
7517 let _inner_offset;
7518 if inlined {
7519 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7520 _inner_offset = offset + 8;
7521 } else {
7522 depth.increment()?;
7523 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7524 }
7525 match ordinal {
7526 1 => {
7527 #[allow(irrefutable_let_patterns)]
7528 if let AudioOffloadFeatures::Sbc(_) = self {
7529 } else {
7531 *self = AudioOffloadFeatures::Sbc(fidl::new_empty!(AudioSbcSupport, D));
7533 }
7534 #[allow(irrefutable_let_patterns)]
7535 if let AudioOffloadFeatures::Sbc(ref mut val) = self {
7536 fidl::decode!(AudioSbcSupport, D, val, decoder, _inner_offset, depth)?;
7537 } else {
7538 unreachable!()
7539 }
7540 }
7541 2 => {
7542 #[allow(irrefutable_let_patterns)]
7543 if let AudioOffloadFeatures::Aac(_) = self {
7544 } else {
7546 *self = AudioOffloadFeatures::Aac(fidl::new_empty!(AudioAacSupport, D));
7548 }
7549 #[allow(irrefutable_let_patterns)]
7550 if let AudioOffloadFeatures::Aac(ref mut val) = self {
7551 fidl::decode!(AudioAacSupport, D, val, decoder, _inner_offset, depth)?;
7552 } else {
7553 unreachable!()
7554 }
7555 }
7556 #[allow(deprecated)]
7557 ordinal => {
7558 for _ in 0..num_handles {
7559 decoder.drop_next_handle()?;
7560 }
7561 *self = AudioOffloadFeatures::__SourceBreaking { unknown_ordinal: ordinal };
7562 }
7563 }
7564 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7565 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7566 }
7567 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7568 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7569 }
7570 Ok(())
7571 }
7572 }
7573
7574 impl fidl::encoding::ValueTypeMarker for ConnectParameters {
7575 type Borrowed<'a> = &'a Self;
7576 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7577 value
7578 }
7579 }
7580
7581 unsafe impl fidl::encoding::TypeMarker for ConnectParameters {
7582 type Owned = Self;
7583
7584 #[inline(always)]
7585 fn inline_align(_context: fidl::encoding::Context) -> usize {
7586 8
7587 }
7588
7589 #[inline(always)]
7590 fn inline_size(_context: fidl::encoding::Context) -> usize {
7591 16
7592 }
7593 }
7594
7595 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectParameters, D>
7596 for &ConnectParameters
7597 {
7598 #[inline]
7599 unsafe fn encode(
7600 self,
7601 encoder: &mut fidl::encoding::Encoder<'_, D>,
7602 offset: usize,
7603 _depth: fidl::encoding::Depth,
7604 ) -> fidl::Result<()> {
7605 encoder.debug_check_bounds::<ConnectParameters>(offset);
7606 encoder.write_num::<u64>(self.ordinal(), offset);
7607 match self {
7608 ConnectParameters::L2cap(ref val) => {
7609 fidl::encoding::encode_in_envelope::<L2capParameters, D>(
7610 <L2capParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
7611 encoder,
7612 offset + 8,
7613 _depth,
7614 )
7615 }
7616 ConnectParameters::Rfcomm(ref val) => {
7617 fidl::encoding::encode_in_envelope::<RfcommParameters, D>(
7618 <RfcommParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
7619 encoder,
7620 offset + 8,
7621 _depth,
7622 )
7623 }
7624 }
7625 }
7626 }
7627
7628 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectParameters {
7629 #[inline(always)]
7630 fn new_empty() -> Self {
7631 Self::L2cap(fidl::new_empty!(L2capParameters, D))
7632 }
7633
7634 #[inline]
7635 unsafe fn decode(
7636 &mut self,
7637 decoder: &mut fidl::encoding::Decoder<'_, D>,
7638 offset: usize,
7639 mut depth: fidl::encoding::Depth,
7640 ) -> fidl::Result<()> {
7641 decoder.debug_check_bounds::<Self>(offset);
7642 #[allow(unused_variables)]
7643 let next_out_of_line = decoder.next_out_of_line();
7644 let handles_before = decoder.remaining_handles();
7645 let (ordinal, inlined, num_bytes, num_handles) =
7646 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7647
7648 let member_inline_size = match ordinal {
7649 1 => <L2capParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7650 2 => <RfcommParameters as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7651 _ => return Err(fidl::Error::UnknownUnionTag),
7652 };
7653
7654 if inlined != (member_inline_size <= 4) {
7655 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7656 }
7657 let _inner_offset;
7658 if inlined {
7659 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7660 _inner_offset = offset + 8;
7661 } else {
7662 depth.increment()?;
7663 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7664 }
7665 match ordinal {
7666 1 => {
7667 #[allow(irrefutable_let_patterns)]
7668 if let ConnectParameters::L2cap(_) = self {
7669 } else {
7671 *self = ConnectParameters::L2cap(fidl::new_empty!(L2capParameters, D));
7673 }
7674 #[allow(irrefutable_let_patterns)]
7675 if let ConnectParameters::L2cap(ref mut val) = self {
7676 fidl::decode!(L2capParameters, D, val, decoder, _inner_offset, depth)?;
7677 } else {
7678 unreachable!()
7679 }
7680 }
7681 2 => {
7682 #[allow(irrefutable_let_patterns)]
7683 if let ConnectParameters::Rfcomm(_) = self {
7684 } else {
7686 *self = ConnectParameters::Rfcomm(fidl::new_empty!(RfcommParameters, D));
7688 }
7689 #[allow(irrefutable_let_patterns)]
7690 if let ConnectParameters::Rfcomm(ref mut val) = self {
7691 fidl::decode!(RfcommParameters, D, val, decoder, _inner_offset, depth)?;
7692 } else {
7693 unreachable!()
7694 }
7695 }
7696 ordinal => panic!("unexpected ordinal {:?}", ordinal),
7697 }
7698 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
7699 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7700 }
7701 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7702 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7703 }
7704 Ok(())
7705 }
7706 }
7707
7708 impl fidl::encoding::ValueTypeMarker for DataElement {
7709 type Borrowed<'a> = &'a Self;
7710 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7711 value
7712 }
7713 }
7714
7715 unsafe impl fidl::encoding::TypeMarker for DataElement {
7716 type Owned = Self;
7717
7718 #[inline(always)]
7719 fn inline_align(_context: fidl::encoding::Context) -> usize {
7720 8
7721 }
7722
7723 #[inline(always)]
7724 fn inline_size(_context: fidl::encoding::Context) -> usize {
7725 16
7726 }
7727 }
7728
7729 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DataElement, D>
7730 for &DataElement
7731 {
7732 #[inline]
7733 unsafe fn encode(
7734 self,
7735 encoder: &mut fidl::encoding::Encoder<'_, D>,
7736 offset: usize,
7737 _depth: fidl::encoding::Depth,
7738 ) -> fidl::Result<()> {
7739 encoder.debug_check_bounds::<DataElement>(offset);
7740 encoder.write_num::<u64>(self.ordinal(), offset);
7741 match self {
7742 DataElement::Int8(ref val) => {
7743 fidl::encoding::encode_in_envelope::<i8, D>(
7744 <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
7745 encoder, offset + 8, _depth
7746 )
7747 }
7748 DataElement::Int16(ref val) => {
7749 fidl::encoding::encode_in_envelope::<i16, D>(
7750 <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
7751 encoder, offset + 8, _depth
7752 )
7753 }
7754 DataElement::Int32(ref val) => {
7755 fidl::encoding::encode_in_envelope::<i32, D>(
7756 <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
7757 encoder, offset + 8, _depth
7758 )
7759 }
7760 DataElement::Int64(ref val) => {
7761 fidl::encoding::encode_in_envelope::<i64, D>(
7762 <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
7763 encoder, offset + 8, _depth
7764 )
7765 }
7766 DataElement::Uint8(ref val) => {
7767 fidl::encoding::encode_in_envelope::<u8, D>(
7768 <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
7769 encoder, offset + 8, _depth
7770 )
7771 }
7772 DataElement::Uint16(ref val) => {
7773 fidl::encoding::encode_in_envelope::<u16, D>(
7774 <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
7775 encoder, offset + 8, _depth
7776 )
7777 }
7778 DataElement::Uint32(ref val) => {
7779 fidl::encoding::encode_in_envelope::<u32, D>(
7780 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
7781 encoder, offset + 8, _depth
7782 )
7783 }
7784 DataElement::Uint64(ref val) => {
7785 fidl::encoding::encode_in_envelope::<u64, D>(
7786 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
7787 encoder, offset + 8, _depth
7788 )
7789 }
7790 DataElement::Str(ref val) => {
7791 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 1024>, D>(
7792 <fidl::encoding::Vector<u8, 1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
7793 encoder, offset + 8, _depth
7794 )
7795 }
7796 DataElement::Url(ref val) => {
7797 fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4096>, D>(
7798 <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(val),
7799 encoder, offset + 8, _depth
7800 )
7801 }
7802 DataElement::Uuid(ref val) => {
7803 fidl::encoding::encode_in_envelope::<fidl_fuchsia_bluetooth__common::Uuid, D>(
7804 <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(val),
7805 encoder, offset + 8, _depth
7806 )
7807 }
7808 DataElement::B(ref val) => {
7809 fidl::encoding::encode_in_envelope::<bool, D>(
7810 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
7811 encoder, offset + 8, _depth
7812 )
7813 }
7814 DataElement::Sequence(ref val) => {
7815 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>, D>(
7816 <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
7817 encoder, offset + 8, _depth
7818 )
7819 }
7820 DataElement::Alternatives(ref val) => {
7821 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>, D>(
7822 <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
7823 encoder, offset + 8, _depth
7824 )
7825 }
7826 DataElement::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
7827 }
7828 }
7829 }
7830
7831 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataElement {
7832 #[inline(always)]
7833 fn new_empty() -> Self {
7834 Self::__SourceBreaking { unknown_ordinal: 0 }
7835 }
7836
7837 #[inline]
7838 unsafe fn decode(
7839 &mut self,
7840 decoder: &mut fidl::encoding::Decoder<'_, D>,
7841 offset: usize,
7842 mut depth: fidl::encoding::Depth,
7843 ) -> fidl::Result<()> {
7844 decoder.debug_check_bounds::<Self>(offset);
7845 #[allow(unused_variables)]
7846 let next_out_of_line = decoder.next_out_of_line();
7847 let handles_before = decoder.remaining_handles();
7848 let (ordinal, inlined, num_bytes, num_handles) =
7849 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
7850
7851 let member_inline_size = match ordinal {
7852 1 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7853 2 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7854 3 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7855 4 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7856 5 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7857 6 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7858 7 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7859 8 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7860 9 => <fidl::encoding::Vector<u8, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7861 10 => <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7862 11 => <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7863 12 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7864 13 => <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7865 14 => <fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
7866 0 => return Err(fidl::Error::UnknownUnionTag),
7867 _ => num_bytes as usize,
7868 };
7869
7870 if inlined != (member_inline_size <= 4) {
7871 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7872 }
7873 let _inner_offset;
7874 if inlined {
7875 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
7876 _inner_offset = offset + 8;
7877 } else {
7878 depth.increment()?;
7879 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7880 }
7881 match ordinal {
7882 1 => {
7883 #[allow(irrefutable_let_patterns)]
7884 if let DataElement::Int8(_) = self {
7885 } else {
7887 *self = DataElement::Int8(fidl::new_empty!(i8, D));
7889 }
7890 #[allow(irrefutable_let_patterns)]
7891 if let DataElement::Int8(ref mut val) = self {
7892 fidl::decode!(i8, D, val, decoder, _inner_offset, depth)?;
7893 } else {
7894 unreachable!()
7895 }
7896 }
7897 2 => {
7898 #[allow(irrefutable_let_patterns)]
7899 if let DataElement::Int16(_) = self {
7900 } else {
7902 *self = DataElement::Int16(fidl::new_empty!(i16, D));
7904 }
7905 #[allow(irrefutable_let_patterns)]
7906 if let DataElement::Int16(ref mut val) = self {
7907 fidl::decode!(i16, D, val, decoder, _inner_offset, depth)?;
7908 } else {
7909 unreachable!()
7910 }
7911 }
7912 3 => {
7913 #[allow(irrefutable_let_patterns)]
7914 if let DataElement::Int32(_) = self {
7915 } else {
7917 *self = DataElement::Int32(fidl::new_empty!(i32, D));
7919 }
7920 #[allow(irrefutable_let_patterns)]
7921 if let DataElement::Int32(ref mut val) = self {
7922 fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
7923 } else {
7924 unreachable!()
7925 }
7926 }
7927 4 => {
7928 #[allow(irrefutable_let_patterns)]
7929 if let DataElement::Int64(_) = self {
7930 } else {
7932 *self = DataElement::Int64(fidl::new_empty!(i64, D));
7934 }
7935 #[allow(irrefutable_let_patterns)]
7936 if let DataElement::Int64(ref mut val) = self {
7937 fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
7938 } else {
7939 unreachable!()
7940 }
7941 }
7942 5 => {
7943 #[allow(irrefutable_let_patterns)]
7944 if let DataElement::Uint8(_) = self {
7945 } else {
7947 *self = DataElement::Uint8(fidl::new_empty!(u8, D));
7949 }
7950 #[allow(irrefutable_let_patterns)]
7951 if let DataElement::Uint8(ref mut val) = self {
7952 fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
7953 } else {
7954 unreachable!()
7955 }
7956 }
7957 6 => {
7958 #[allow(irrefutable_let_patterns)]
7959 if let DataElement::Uint16(_) = self {
7960 } else {
7962 *self = DataElement::Uint16(fidl::new_empty!(u16, D));
7964 }
7965 #[allow(irrefutable_let_patterns)]
7966 if let DataElement::Uint16(ref mut val) = self {
7967 fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
7968 } else {
7969 unreachable!()
7970 }
7971 }
7972 7 => {
7973 #[allow(irrefutable_let_patterns)]
7974 if let DataElement::Uint32(_) = self {
7975 } else {
7977 *self = DataElement::Uint32(fidl::new_empty!(u32, D));
7979 }
7980 #[allow(irrefutable_let_patterns)]
7981 if let DataElement::Uint32(ref mut val) = self {
7982 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
7983 } else {
7984 unreachable!()
7985 }
7986 }
7987 8 => {
7988 #[allow(irrefutable_let_patterns)]
7989 if let DataElement::Uint64(_) = self {
7990 } else {
7992 *self = DataElement::Uint64(fidl::new_empty!(u64, D));
7994 }
7995 #[allow(irrefutable_let_patterns)]
7996 if let DataElement::Uint64(ref mut val) = self {
7997 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
7998 } else {
7999 unreachable!()
8000 }
8001 }
8002 9 => {
8003 #[allow(irrefutable_let_patterns)]
8004 if let DataElement::Str(_) = self {
8005 } else {
8007 *self =
8009 DataElement::Str(fidl::new_empty!(fidl::encoding::Vector<u8, 1024>, D));
8010 }
8011 #[allow(irrefutable_let_patterns)]
8012 if let DataElement::Str(ref mut val) = self {
8013 fidl::decode!(fidl::encoding::Vector<u8, 1024>, D, val, decoder, _inner_offset, depth)?;
8014 } else {
8015 unreachable!()
8016 }
8017 }
8018 10 => {
8019 #[allow(irrefutable_let_patterns)]
8020 if let DataElement::Url(_) = self {
8021 } else {
8023 *self = DataElement::Url(fidl::new_empty!(
8025 fidl::encoding::BoundedString<4096>,
8026 D
8027 ));
8028 }
8029 #[allow(irrefutable_let_patterns)]
8030 if let DataElement::Url(ref mut val) = self {
8031 fidl::decode!(
8032 fidl::encoding::BoundedString<4096>,
8033 D,
8034 val,
8035 decoder,
8036 _inner_offset,
8037 depth
8038 )?;
8039 } else {
8040 unreachable!()
8041 }
8042 }
8043 11 => {
8044 #[allow(irrefutable_let_patterns)]
8045 if let DataElement::Uuid(_) = self {
8046 } else {
8048 *self = DataElement::Uuid(fidl::new_empty!(
8050 fidl_fuchsia_bluetooth__common::Uuid,
8051 D
8052 ));
8053 }
8054 #[allow(irrefutable_let_patterns)]
8055 if let DataElement::Uuid(ref mut val) = self {
8056 fidl::decode!(
8057 fidl_fuchsia_bluetooth__common::Uuid,
8058 D,
8059 val,
8060 decoder,
8061 _inner_offset,
8062 depth
8063 )?;
8064 } else {
8065 unreachable!()
8066 }
8067 }
8068 12 => {
8069 #[allow(irrefutable_let_patterns)]
8070 if let DataElement::B(_) = self {
8071 } else {
8073 *self = DataElement::B(fidl::new_empty!(bool, D));
8075 }
8076 #[allow(irrefutable_let_patterns)]
8077 if let DataElement::B(ref mut val) = self {
8078 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
8079 } else {
8080 unreachable!()
8081 }
8082 }
8083 13 => {
8084 #[allow(irrefutable_let_patterns)]
8085 if let DataElement::Sequence(_) = self {
8086 } else {
8088 *self = DataElement::Sequence(fidl::new_empty!(
8090 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8091 D
8092 ));
8093 }
8094 #[allow(irrefutable_let_patterns)]
8095 if let DataElement::Sequence(ref mut val) = self {
8096 fidl::decode!(
8097 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8098 D,
8099 val,
8100 decoder,
8101 _inner_offset,
8102 depth
8103 )?;
8104 } else {
8105 unreachable!()
8106 }
8107 }
8108 14 => {
8109 #[allow(irrefutable_let_patterns)]
8110 if let DataElement::Alternatives(_) = self {
8111 } else {
8113 *self = DataElement::Alternatives(fidl::new_empty!(
8115 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8116 D
8117 ));
8118 }
8119 #[allow(irrefutable_let_patterns)]
8120 if let DataElement::Alternatives(ref mut val) = self {
8121 fidl::decode!(
8122 fidl::encoding::Vector<fidl::encoding::OptionalUnion<DataElement>, 255>,
8123 D,
8124 val,
8125 decoder,
8126 _inner_offset,
8127 depth
8128 )?;
8129 } else {
8130 unreachable!()
8131 }
8132 }
8133 #[allow(deprecated)]
8134 ordinal => {
8135 for _ in 0..num_handles {
8136 decoder.drop_next_handle()?;
8137 }
8138 *self = DataElement::__SourceBreaking { unknown_ordinal: ordinal };
8139 }
8140 }
8141 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8142 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8143 }
8144 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8145 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8146 }
8147 Ok(())
8148 }
8149 }
8150
8151 impl fidl::encoding::ValueTypeMarker for ScoConnectionOnConnectionCompleteRequest {
8152 type Borrowed<'a> = &'a Self;
8153 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8154 value
8155 }
8156 }
8157
8158 unsafe impl fidl::encoding::TypeMarker for ScoConnectionOnConnectionCompleteRequest {
8159 type Owned = Self;
8160
8161 #[inline(always)]
8162 fn inline_align(_context: fidl::encoding::Context) -> usize {
8163 8
8164 }
8165
8166 #[inline(always)]
8167 fn inline_size(_context: fidl::encoding::Context) -> usize {
8168 16
8169 }
8170 }
8171
8172 unsafe impl<D: fidl::encoding::ResourceDialect>
8173 fidl::encoding::Encode<ScoConnectionOnConnectionCompleteRequest, D>
8174 for &ScoConnectionOnConnectionCompleteRequest
8175 {
8176 #[inline]
8177 unsafe fn encode(
8178 self,
8179 encoder: &mut fidl::encoding::Encoder<'_, D>,
8180 offset: usize,
8181 _depth: fidl::encoding::Depth,
8182 ) -> fidl::Result<()> {
8183 encoder.debug_check_bounds::<ScoConnectionOnConnectionCompleteRequest>(offset);
8184 encoder.write_num::<u64>(self.ordinal(), offset);
8185 match self {
8186 ScoConnectionOnConnectionCompleteRequest::ConnectedParams(ref val) => {
8187 fidl::encoding::encode_in_envelope::<ScoConnectionParameters, D>(
8188 <ScoConnectionParameters as fidl::encoding::ValueTypeMarker>::borrow(val),
8189 encoder,
8190 offset + 8,
8191 _depth,
8192 )
8193 }
8194 ScoConnectionOnConnectionCompleteRequest::Error(ref val) => {
8195 fidl::encoding::encode_in_envelope::<ScoErrorCode, D>(
8196 <ScoErrorCode as fidl::encoding::ValueTypeMarker>::borrow(val),
8197 encoder,
8198 offset + 8,
8199 _depth,
8200 )
8201 }
8202 ScoConnectionOnConnectionCompleteRequest::__SourceBreaking { .. } => {
8203 Err(fidl::Error::UnknownUnionTag)
8204 }
8205 }
8206 }
8207 }
8208
8209 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8210 for ScoConnectionOnConnectionCompleteRequest
8211 {
8212 #[inline(always)]
8213 fn new_empty() -> Self {
8214 Self::__SourceBreaking { unknown_ordinal: 0 }
8215 }
8216
8217 #[inline]
8218 unsafe fn decode(
8219 &mut self,
8220 decoder: &mut fidl::encoding::Decoder<'_, D>,
8221 offset: usize,
8222 mut depth: fidl::encoding::Depth,
8223 ) -> fidl::Result<()> {
8224 decoder.debug_check_bounds::<Self>(offset);
8225 #[allow(unused_variables)]
8226 let next_out_of_line = decoder.next_out_of_line();
8227 let handles_before = decoder.remaining_handles();
8228 let (ordinal, inlined, num_bytes, num_handles) =
8229 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
8230
8231 let member_inline_size = match ordinal {
8232 1 => <ScoConnectionParameters as fidl::encoding::TypeMarker>::inline_size(
8233 decoder.context,
8234 ),
8235 2 => <ScoErrorCode as fidl::encoding::TypeMarker>::inline_size(decoder.context),
8236 0 => return Err(fidl::Error::UnknownUnionTag),
8237 _ => num_bytes as usize,
8238 };
8239
8240 if inlined != (member_inline_size <= 4) {
8241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8242 }
8243 let _inner_offset;
8244 if inlined {
8245 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
8246 _inner_offset = offset + 8;
8247 } else {
8248 depth.increment()?;
8249 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8250 }
8251 match ordinal {
8252 1 => {
8253 #[allow(irrefutable_let_patterns)]
8254 if let ScoConnectionOnConnectionCompleteRequest::ConnectedParams(_) = self {
8255 } else {
8257 *self = ScoConnectionOnConnectionCompleteRequest::ConnectedParams(
8259 fidl::new_empty!(ScoConnectionParameters, D),
8260 );
8261 }
8262 #[allow(irrefutable_let_patterns)]
8263 if let ScoConnectionOnConnectionCompleteRequest::ConnectedParams(ref mut val) =
8264 self
8265 {
8266 fidl::decode!(
8267 ScoConnectionParameters,
8268 D,
8269 val,
8270 decoder,
8271 _inner_offset,
8272 depth
8273 )?;
8274 } else {
8275 unreachable!()
8276 }
8277 }
8278 2 => {
8279 #[allow(irrefutable_let_patterns)]
8280 if let ScoConnectionOnConnectionCompleteRequest::Error(_) = self {
8281 } else {
8283 *self = ScoConnectionOnConnectionCompleteRequest::Error(fidl::new_empty!(
8285 ScoErrorCode,
8286 D
8287 ));
8288 }
8289 #[allow(irrefutable_let_patterns)]
8290 if let ScoConnectionOnConnectionCompleteRequest::Error(ref mut val) = self {
8291 fidl::decode!(ScoErrorCode, D, val, decoder, _inner_offset, depth)?;
8292 } else {
8293 unreachable!()
8294 }
8295 }
8296 #[allow(deprecated)]
8297 ordinal => {
8298 for _ in 0..num_handles {
8299 decoder.drop_next_handle()?;
8300 }
8301 *self = ScoConnectionOnConnectionCompleteRequest::__SourceBreaking {
8302 unknown_ordinal: ordinal,
8303 };
8304 }
8305 }
8306 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8307 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8308 }
8309 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8310 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8311 }
8312 Ok(())
8313 }
8314 }
8315}