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