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