1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type LocalKey = Key;
13
14pub const MAX_PEER_SERVICES: u16 = 65535;
17
18#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum BondableMode {
23 Bondable = 1,
25 NonBondable = 2,
27}
28
29impl BondableMode {
30 #[inline]
31 pub fn from_primitive(prim: u32) -> Option<Self> {
32 match prim {
33 1 => Some(Self::Bondable),
34 2 => Some(Self::NonBondable),
35 _ => None,
36 }
37 }
38
39 #[inline]
40 pub const fn into_primitive(self) -> u32 {
41 self as u32
42 }
43}
44
45#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
46#[repr(u32)]
47pub enum BootstrapError {
48 InvalidHostIdentity = 1,
49 WriteFailure = 2,
50}
51
52impl BootstrapError {
53 #[inline]
54 pub fn from_primitive(prim: u32) -> Option<Self> {
55 match prim {
56 1 => Some(Self::InvalidHostIdentity),
57 2 => Some(Self::WriteFailure),
58 _ => None,
59 }
60 }
61
62 #[inline]
63 pub const fn into_primitive(self) -> u32 {
64 self as u32
65 }
66}
67
68#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
73#[repr(u32)]
74pub enum BrEdrSecurityMode {
75 Mode4 = 1,
80 SecureConnectionsOnly = 2,
86}
87
88impl BrEdrSecurityMode {
89 #[inline]
90 pub fn from_primitive(prim: u32) -> Option<Self> {
91 match prim {
92 1 => Some(Self::Mode4),
93 2 => Some(Self::SecureConnectionsOnly),
94 _ => None,
95 }
96 }
97
98 #[inline]
99 pub const fn into_primitive(self) -> u32 {
100 self as u32
101 }
102}
103
104#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
105#[repr(u32)]
106pub enum Error {
107 Failed = 1,
109 PeerNotFound = 2,
111 TimedOut = 3,
113 Canceled = 4,
115 InProgress = 5,
117 NotSupported = 6,
119 InvalidArguments = 7,
121}
122
123impl Error {
124 #[inline]
125 pub fn from_primitive(prim: u32) -> Option<Self> {
126 match prim {
127 1 => Some(Self::Failed),
128 2 => Some(Self::PeerNotFound),
129 3 => Some(Self::TimedOut),
130 4 => Some(Self::Canceled),
131 5 => Some(Self::InProgress),
132 6 => Some(Self::NotSupported),
133 7 => Some(Self::InvalidArguments),
134 _ => None,
135 }
136 }
137
138 #[inline]
139 pub const fn into_primitive(self) -> u32 {
140 self as u32
141 }
142}
143
144#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
149#[repr(u32)]
150pub enum InputCapability {
151 None = 1,
156 Confirmation = 2,
158 Keyboard = 3,
161}
162
163impl InputCapability {
164 #[inline]
165 pub fn from_primitive(prim: u32) -> Option<Self> {
166 match prim {
167 1 => Some(Self::None),
168 2 => Some(Self::Confirmation),
169 3 => Some(Self::Keyboard),
170 _ => None,
171 }
172 }
173
174 #[inline]
175 pub const fn into_primitive(self) -> u32 {
176 self as u32
177 }
178}
179
180#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
185#[repr(u32)]
186pub enum LeSecurityMode {
187 Mode1 = 1,
191 SecureConnectionsOnly = 2,
197}
198
199impl LeSecurityMode {
200 #[inline]
201 pub fn from_primitive(prim: u32) -> Option<Self> {
202 match prim {
203 1 => Some(Self::Mode1),
204 2 => Some(Self::SecureConnectionsOnly),
205 _ => None,
206 }
207 }
208
209 #[inline]
210 pub const fn into_primitive(self) -> u32 {
211 self as u32
212 }
213}
214
215#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
216pub enum LookupError {
217 NotFound,
218 MissingArgument,
219 #[doc(hidden)]
220 __SourceBreaking {
221 unknown_ordinal: u32,
222 },
223}
224
225#[macro_export]
227macro_rules! LookupErrorUnknown {
228 () => {
229 _
230 };
231}
232
233impl LookupError {
234 #[inline]
235 pub fn from_primitive(prim: u32) -> Option<Self> {
236 match prim {
237 0 => Some(Self::NotFound),
238 1 => Some(Self::MissingArgument),
239 _ => None,
240 }
241 }
242
243 #[inline]
244 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
245 match prim {
246 0 => Self::NotFound,
247 1 => Self::MissingArgument,
248 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
249 }
250 }
251
252 #[inline]
253 pub fn unknown() -> Self {
254 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
255 }
256
257 #[inline]
258 pub const fn into_primitive(self) -> u32 {
259 match self {
260 Self::NotFound => 0,
261 Self::MissingArgument => 1,
262 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
263 }
264 }
265
266 #[inline]
267 pub fn is_unknown(&self) -> bool {
268 match self {
269 Self::__SourceBreaking { unknown_ordinal: _ } => true,
270 _ => false,
271 }
272 }
273}
274
275#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
280#[repr(u32)]
281pub enum OutputCapability {
282 None = 1,
284 Display = 2,
286}
287
288impl OutputCapability {
289 #[inline]
290 pub fn from_primitive(prim: u32) -> Option<Self> {
291 match prim {
292 1 => Some(Self::None),
293 2 => Some(Self::Display),
294 _ => None,
295 }
296 }
297
298 #[inline]
299 pub const fn into_primitive(self) -> u32 {
300 self as u32
301 }
302}
303
304#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
308#[repr(u32)]
309pub enum PairingKeypress {
310 DigitEntered = 1,
312 DigitErased = 2,
314 PasskeyCleared = 3,
316 PasskeyEntered = 4,
318}
319
320impl PairingKeypress {
321 #[inline]
322 pub fn from_primitive(prim: u32) -> Option<Self> {
323 match prim {
324 1 => Some(Self::DigitEntered),
325 2 => Some(Self::DigitErased),
326 3 => Some(Self::PasskeyCleared),
327 4 => Some(Self::PasskeyEntered),
328 _ => None,
329 }
330 }
331
332 #[inline]
333 pub const fn into_primitive(self) -> u32 {
334 self as u32
335 }
336}
337
338#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
341#[repr(u32)]
342pub enum PairingMethod {
343 Consent = 1,
348 PasskeyDisplay = 2,
351 PasskeyComparison = 3,
355 PasskeyEntry = 4,
358}
359
360impl PairingMethod {
361 #[inline]
362 pub fn from_primitive(prim: u32) -> Option<Self> {
363 match prim {
364 1 => Some(Self::Consent),
365 2 => Some(Self::PasskeyDisplay),
366 3 => Some(Self::PasskeyComparison),
367 4 => Some(Self::PasskeyEntry),
368 _ => None,
369 }
370 }
371
372 #[inline]
373 pub const fn into_primitive(self) -> u32 {
374 self as u32
375 }
376}
377
378#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
381#[repr(u32)]
382pub enum PairingSecurityLevel {
383 Encrypted = 1,
385 Authenticated = 2,
388}
389
390impl PairingSecurityLevel {
391 #[inline]
392 pub fn from_primitive(prim: u32) -> Option<Self> {
393 match prim {
394 1 => Some(Self::Encrypted),
395 2 => Some(Self::Authenticated),
396 _ => None,
397 }
398 }
399
400 #[inline]
401 pub const fn into_primitive(self) -> u32 {
402 self as u32
403 }
404}
405
406#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
407#[repr(u32)]
408pub enum TechnologyType {
409 LowEnergy = 1,
410 Classic = 2,
411 DualMode = 3,
412}
413
414impl TechnologyType {
415 #[inline]
416 pub fn from_primitive(prim: u32) -> Option<Self> {
417 match prim {
418 1 => Some(Self::LowEnergy),
419 2 => Some(Self::Classic),
420 3 => Some(Self::DualMode),
421 _ => None,
422 }
423 }
424
425 #[inline]
426 pub const fn into_primitive(self) -> u32 {
427 self as u32
428 }
429}
430
431#[derive(Clone, Debug, PartialEq)]
432pub struct AccessConnectRequest {
433 pub id: fidl_fuchsia_bluetooth__common::PeerId,
434}
435
436impl fidl::Persistable for AccessConnectRequest {}
437
438#[derive(Clone, Debug, PartialEq)]
439pub struct AccessDisconnectRequest {
440 pub id: fidl_fuchsia_bluetooth__common::PeerId,
441}
442
443impl fidl::Persistable for AccessDisconnectRequest {}
444
445#[derive(Clone, Debug, PartialEq)]
446pub struct AccessForgetRequest {
447 pub id: fidl_fuchsia_bluetooth__common::PeerId,
448}
449
450impl fidl::Persistable for AccessForgetRequest {}
451
452#[derive(Clone, Debug, PartialEq)]
453pub struct AccessPairRequest {
454 pub id: fidl_fuchsia_bluetooth__common::PeerId,
455 pub options: PairingOptions,
456}
457
458impl fidl::Persistable for AccessPairRequest {}
459
460#[derive(Clone, Debug, PartialEq)]
461pub struct AccessSetDeviceClassRequest {
462 pub device_class: fidl_fuchsia_bluetooth__common::DeviceClass,
463}
464
465impl fidl::Persistable for AccessSetDeviceClassRequest {}
466
467#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
468pub struct AccessSetLocalNameRequest {
469 pub name: String,
470}
471
472impl fidl::Persistable for AccessSetLocalNameRequest {}
473
474#[derive(Clone, Debug, PartialEq)]
475pub struct AccessWatchPeersResponse {
476 pub updated: Vec<Peer>,
477 pub removed: Vec<fidl_fuchsia_bluetooth__common::PeerId>,
478}
479
480impl fidl::Persistable for AccessWatchPeersResponse {}
481
482#[derive(Clone, Debug, PartialEq)]
483pub struct AddressLookupLookupResponse {
484 pub bd_addr: fidl_fuchsia_bluetooth__common::Address,
485}
486
487impl fidl::Persistable for AddressLookupLookupResponse {}
488
489#[derive(Clone, Debug, PartialEq)]
490pub struct BootstrapAddIdentitiesRequest {
491 pub identities: Vec<Identity>,
492}
493
494impl fidl::Persistable for BootstrapAddIdentitiesRequest {}
495
496#[derive(Clone, Debug, PartialEq)]
497pub struct ConfigurationUpdateRequest {
498 pub settings: Settings,
499}
500
501impl fidl::Persistable for ConfigurationUpdateRequest {}
502
503#[derive(Clone, Debug, PartialEq)]
504pub struct ConfigurationUpdateResponse {
505 pub result: Settings,
506}
507
508impl fidl::Persistable for ConfigurationUpdateResponse {}
509
510#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
511pub struct Consent;
512
513impl fidl::Persistable for Consent {}
514
515#[derive(Clone, Debug, PartialEq)]
516pub struct HostWatcherSetActiveRequest {
517 pub id: fidl_fuchsia_bluetooth__common::HostId,
518}
519
520impl fidl::Persistable for HostWatcherSetActiveRequest {}
521
522#[derive(Clone, Debug, PartialEq)]
523pub struct HostWatcherWatchResponse {
524 pub hosts: Vec<HostInfo>,
525}
526
527impl fidl::Persistable for HostWatcherWatchResponse {}
528
529#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
531#[repr(C)]
532pub struct Key {
533 pub value: [u8; 16],
534}
535
536impl fidl::Persistable for Key {}
537
538#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
540#[repr(C)]
541pub struct LeConnectionParameters {
542 pub connection_interval: u16,
543 pub connection_latency: u16,
544 pub supervision_timeout: u16,
545}
546
547impl fidl::Persistable for LeConnectionParameters {}
548
549#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
552pub struct Ltk {
553 pub key: PeerKey,
554 pub ediv: u16,
555 pub rand: u64,
556}
557
558impl fidl::Persistable for Ltk {}
559
560#[derive(Clone, Debug, PartialEq)]
561pub struct PairingDelegate2RequestCompleteRequest {
562 pub id: fidl_fuchsia_bluetooth__common::PeerId,
563 pub success: bool,
564}
565
566impl fidl::Persistable for PairingDelegate2RequestCompleteRequest {}
567
568#[derive(Clone, Debug, PartialEq)]
569pub struct PairingDelegateOnLocalKeypressRequest {
570 pub id: fidl_fuchsia_bluetooth__common::PeerId,
571 pub keypress: PairingKeypress,
572}
573
574impl fidl::Persistable for PairingDelegateOnLocalKeypressRequest {}
575
576#[derive(Clone, Debug, PartialEq)]
577pub struct PairingDelegateOnPairingCompleteRequest {
578 pub id: fidl_fuchsia_bluetooth__common::PeerId,
579 pub success: bool,
580}
581
582impl fidl::Persistable for PairingDelegateOnPairingCompleteRequest {}
583
584#[derive(Clone, Debug, PartialEq)]
585pub struct PairingDelegateOnPairingRequestRequest {
586 pub peer: Peer,
587 pub method: PairingMethod,
588 pub displayed_passkey: u32,
589}
590
591impl fidl::Persistable for PairingDelegateOnPairingRequestRequest {}
592
593#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
594pub struct PairingDelegateOnPairingRequestResponse {
595 pub accept: bool,
596 pub entered_passkey: u32,
597}
598
599impl fidl::Persistable for PairingDelegateOnPairingRequestResponse {}
600
601#[derive(Clone, Debug, PartialEq)]
602pub struct PairingDelegateOnRemoteKeypressRequest {
603 pub id: fidl_fuchsia_bluetooth__common::PeerId,
604 pub keypress: PairingKeypress,
605}
606
607impl fidl::Persistable for PairingDelegateOnRemoteKeypressRequest {}
608
609#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
610pub struct PairingRequestKeypressRequest {
611 pub keypress: PairingKeypress,
612}
613
614impl fidl::Persistable for PairingRequestKeypressRequest {}
615
616#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
617pub struct PairingRequestOnCompleteRequest {
618 pub success: bool,
619}
620
621impl fidl::Persistable for PairingRequestOnCompleteRequest {}
622
623#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
624pub struct PairingRequestOnKeypressRequest {
625 pub keypress: PairingKeypress,
626}
627
628impl fidl::Persistable for PairingRequestOnKeypressRequest {}
629
630#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
631pub struct PasskeyEntry;
632
633impl fidl::Persistable for PasskeyEntry {}
634
635#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
637pub struct PeerKey {
638 pub security: SecurityProperties,
640 pub data: Key,
642}
643
644impl fidl::Persistable for PeerKey {}
645
646#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
647pub struct SecurityProperties {
648 pub authenticated: bool,
649 pub secure_connections: bool,
650 pub encryption_key_size: u8,
651}
652
653impl fidl::Persistable for SecurityProperties {}
654
655#[derive(Clone, Debug, Default, PartialEq)]
656pub struct AddressLookupLookupRequest {
657 pub peer_id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
658 #[doc(hidden)]
659 pub __source_breaking: fidl::marker::SourceBreaking,
660}
661
662impl fidl::Persistable for AddressLookupLookupRequest {}
663
664#[derive(Clone, Debug, Default, PartialEq)]
666pub struct BondingData {
667 pub identifier: Option<fidl_fuchsia_bluetooth__common::PeerId>,
669 pub local_address: Option<fidl_fuchsia_bluetooth__common::Address>,
671 pub name: Option<String>,
673 pub address: Option<fidl_fuchsia_bluetooth__common::Address>,
675 pub le_bond: Option<LeBondData>,
677 pub bredr_bond: Option<BredrBondData>,
679 #[doc(hidden)]
680 pub __source_breaking: fidl::marker::SourceBreaking,
681}
682
683impl fidl::Persistable for BondingData {}
684
685#[derive(Clone, Debug, Default, PartialEq)]
686pub struct BredrBondData {
687 pub role_preference: Option<fidl_fuchsia_bluetooth__common::ConnectionRole>,
691 pub services: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
693 pub link_key: Option<PeerKey>,
696 #[doc(hidden)]
697 pub __source_breaking: fidl::marker::SourceBreaking,
698}
699
700impl fidl::Persistable for BredrBondData {}
701
702#[derive(Clone, Debug, Default, PartialEq)]
704pub struct HostData {
705 pub irk: Option<Key>,
714 #[doc(hidden)]
715 pub __source_breaking: fidl::marker::SourceBreaking,
716}
717
718impl fidl::Persistable for HostData {}
719
720#[derive(Clone, Debug, Default, PartialEq)]
722pub struct HostInfo {
723 pub id: Option<fidl_fuchsia_bluetooth__common::HostId>,
727 pub technology: Option<TechnologyType>,
731 pub active: Option<bool>,
734 pub local_name: Option<String>,
737 pub discoverable: Option<bool>,
740 pub discovering: Option<bool>,
742 pub addresses: Option<Vec<fidl_fuchsia_bluetooth__common::Address>>,
748 #[doc(hidden)]
749 pub __source_breaking: fidl::marker::SourceBreaking,
750}
751
752impl fidl::Persistable for HostInfo {}
753
754#[derive(Clone, Debug, Default, PartialEq)]
764pub struct Identity {
765 pub host: Option<HostData>,
766 pub bonds: Option<Vec<BondingData>>,
768 #[doc(hidden)]
769 pub __source_breaking: fidl::marker::SourceBreaking,
770}
771
772impl fidl::Persistable for Identity {}
773
774#[derive(Clone, Debug, Default, PartialEq)]
775pub struct LeBondData {
776 pub connection_parameters: Option<LeConnectionParameters>,
778 pub services: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
780 pub irk: Option<PeerKey>,
782 pub csrk: Option<PeerKey>,
784 pub peer_ltk: Option<Ltk>,
790 pub local_ltk: Option<Ltk>,
796 #[doc(hidden)]
797 pub __source_breaking: fidl::marker::SourceBreaking,
798}
799
800impl fidl::Persistable for LeBondData {}
801
802#[derive(Clone, Debug, Default, PartialEq)]
805pub struct PairingOptions {
806 pub le_security_level: Option<PairingSecurityLevel>,
809 pub bondable_mode: Option<BondableMode>,
815 pub transport: Option<TechnologyType>,
820 #[doc(hidden)]
821 pub __source_breaking: fidl::marker::SourceBreaking,
822}
823
824impl fidl::Persistable for PairingOptions {}
825
826#[derive(Clone, Debug, Default, PartialEq)]
827pub struct PairingRequestAcceptRequest {
828 pub entered_passkey: Option<u32>,
829 #[doc(hidden)]
830 pub __source_breaking: fidl::marker::SourceBreaking,
831}
832
833impl fidl::Persistable for PairingRequestAcceptRequest {}
834
835#[derive(Clone, Debug, Default, PartialEq)]
837pub struct Peer {
838 pub id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
842 pub address: Option<fidl_fuchsia_bluetooth__common::Address>,
850 pub technology: Option<TechnologyType>,
854 pub connected: Option<bool>,
858 pub bonded: Option<bool>,
862 pub name: Option<String>,
864 pub appearance: Option<fidl_fuchsia_bluetooth__common::Appearance>,
867 pub device_class: Option<fidl_fuchsia_bluetooth__common::DeviceClass>,
869 pub rssi: Option<i8>,
871 pub tx_power: Option<i8>,
873 pub services: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
877 pub le_services: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
881 pub bredr_services: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
888 #[doc(hidden)]
889 pub __source_breaking: fidl::marker::SourceBreaking,
890}
891
892impl fidl::Persistable for Peer {}
893
894#[derive(Clone, Debug, Default, PartialEq)]
898pub struct Settings {
899 pub le_privacy: Option<bool>,
907 pub le_background_scan: Option<bool>,
912 pub bredr_connectable_mode: Option<bool>,
916 pub le_security_mode: Option<LeSecurityMode>,
921 pub bredr_security_mode: Option<BrEdrSecurityMode>,
926 #[doc(hidden)]
927 pub __source_breaking: fidl::marker::SourceBreaking,
928}
929
930impl fidl::Persistable for Settings {}
931
932#[derive(Clone, Debug)]
933pub enum PairingProperties {
934 Consent(Consent),
939 PasskeyDisplay(u32),
943 PasskeyConfirmation(u32),
948 PasskeyEntry(PasskeyEntry),
951 #[doc(hidden)]
952 __SourceBreaking { unknown_ordinal: u64 },
953}
954
955#[macro_export]
957macro_rules! PairingPropertiesUnknown {
958 () => {
959 _
960 };
961}
962
963impl PartialEq for PairingProperties {
965 fn eq(&self, other: &Self) -> bool {
966 match (self, other) {
967 (Self::Consent(x), Self::Consent(y)) => *x == *y,
968 (Self::PasskeyDisplay(x), Self::PasskeyDisplay(y)) => *x == *y,
969 (Self::PasskeyConfirmation(x), Self::PasskeyConfirmation(y)) => *x == *y,
970 (Self::PasskeyEntry(x), Self::PasskeyEntry(y)) => *x == *y,
971 _ => false,
972 }
973 }
974}
975
976impl PairingProperties {
977 #[inline]
978 pub fn ordinal(&self) -> u64 {
979 match *self {
980 Self::Consent(_) => 1,
981 Self::PasskeyDisplay(_) => 2,
982 Self::PasskeyConfirmation(_) => 3,
983 Self::PasskeyEntry(_) => 4,
984 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
985 }
986 }
987
988 #[inline]
989 pub fn unknown_variant_for_testing() -> Self {
990 Self::__SourceBreaking { unknown_ordinal: 0 }
991 }
992
993 #[inline]
994 pub fn is_unknown(&self) -> bool {
995 match self {
996 Self::__SourceBreaking { .. } => true,
997 _ => false,
998 }
999 }
1000}
1001
1002impl fidl::Persistable for PairingProperties {}
1003
1004pub mod access_ordinals {
1005 pub const SET_PAIRING_DELEGATE: u64 = 0x4af398e1f4cdb40b;
1006 pub const SET_LOCAL_NAME: u64 = 0x7d12cd2d902206eb;
1007 pub const SET_DEVICE_CLASS: u64 = 0x58dd8f65f589035d;
1008 pub const MAKE_DISCOVERABLE: u64 = 0x747cadf609c96fb1;
1009 pub const SET_CONNECTION_POLICY: u64 = 0x8e8c7354932fb5a;
1010 pub const START_DISCOVERY: u64 = 0x6907100d9b99439;
1011 pub const WATCH_PEERS: u64 = 0x1921fe1ed8e6eb7c;
1012 pub const CONNECT: u64 = 0x1734199789fe7667;
1013 pub const DISCONNECT: u64 = 0x3a4e06d0c6185a5;
1014 pub const PAIR: u64 = 0x1d08ea19db327779;
1015 pub const FORGET: u64 = 0x1fd8e27202854c0;
1016}
1017
1018pub mod address_lookup_ordinals {
1019 pub const LOOKUP: u64 = 0x65d2ae252ec22587;
1020}
1021
1022pub mod bootstrap_ordinals {
1023 pub const ADD_IDENTITIES: u64 = 0x92d7c849de29bb0;
1024 pub const COMMIT: u64 = 0x5288006c9c7db6b7;
1025}
1026
1027pub mod configuration_ordinals {
1028 pub const UPDATE: u64 = 0x27e9cfb72e7c6d01;
1029}
1030
1031pub mod host_watcher_ordinals {
1032 pub const WATCH: u64 = 0x4e2c2972a5b16f9c;
1033 pub const SET_ACTIVE: u64 = 0x83f311ecaf0ddf3;
1034}
1035
1036pub mod pairing_ordinals {
1037 pub const SET_PAIRING_DELEGATE: u64 = 0x19721a12cb80212c;
1038 pub const SET_DELEGATE: u64 = 0x1da0568d2582a9a5;
1039}
1040
1041pub mod pairing_delegate_ordinals {
1042 pub const ON_PAIRING_REQUEST: u64 = 0x5c483a8f97b226b3;
1043 pub const ON_PAIRING_COMPLETE: u64 = 0x5ad8fc9864eba757;
1044 pub const ON_REMOTE_KEYPRESS: u64 = 0x4e341e41c604c724;
1045 pub const ON_LOCAL_KEYPRESS: u64 = 0x1a764c0428878889;
1046}
1047
1048pub mod pairing_delegate2_ordinals {
1049 pub const START_REQUEST: u64 = 0x2a5ab8092a961a01;
1050 pub const REQUEST_COMPLETE: u64 = 0x4b63b44d5dbca192;
1051}
1052
1053pub mod pairing_request_ordinals {
1054 pub const ACCEPT: u64 = 0x67278857ae043a5;
1055 pub const REJECT: u64 = 0x550414aec8155cf5;
1056 pub const KEYPRESS: u64 = 0x53948ecc921fbe9b;
1057 pub const ON_KEYPRESS: u64 = 0x71a4802e6a5d1aca;
1058 pub const ON_COMPLETE: u64 = 0xd38d3220987bc79;
1059}
1060
1061pub mod procedure_token_ordinals {}
1062
1063mod internal {
1064 use super::*;
1065 unsafe impl fidl::encoding::TypeMarker for BondableMode {
1066 type Owned = Self;
1067
1068 #[inline(always)]
1069 fn inline_align(_context: fidl::encoding::Context) -> usize {
1070 std::mem::align_of::<u32>()
1071 }
1072
1073 #[inline(always)]
1074 fn inline_size(_context: fidl::encoding::Context) -> usize {
1075 std::mem::size_of::<u32>()
1076 }
1077
1078 #[inline(always)]
1079 fn encode_is_copy() -> bool {
1080 true
1081 }
1082
1083 #[inline(always)]
1084 fn decode_is_copy() -> bool {
1085 false
1086 }
1087 }
1088
1089 impl fidl::encoding::ValueTypeMarker for BondableMode {
1090 type Borrowed<'a> = Self;
1091 #[inline(always)]
1092 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1093 *value
1094 }
1095 }
1096
1097 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BondableMode {
1098 #[inline]
1099 unsafe fn encode(
1100 self,
1101 encoder: &mut fidl::encoding::Encoder<'_, D>,
1102 offset: usize,
1103 _depth: fidl::encoding::Depth,
1104 ) -> fidl::Result<()> {
1105 encoder.debug_check_bounds::<Self>(offset);
1106 encoder.write_num(self.into_primitive(), offset);
1107 Ok(())
1108 }
1109 }
1110
1111 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BondableMode {
1112 #[inline(always)]
1113 fn new_empty() -> Self {
1114 Self::Bondable
1115 }
1116
1117 #[inline]
1118 unsafe fn decode(
1119 &mut self,
1120 decoder: &mut fidl::encoding::Decoder<'_, D>,
1121 offset: usize,
1122 _depth: fidl::encoding::Depth,
1123 ) -> fidl::Result<()> {
1124 decoder.debug_check_bounds::<Self>(offset);
1125 let prim = decoder.read_num::<u32>(offset);
1126
1127 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1128 Ok(())
1129 }
1130 }
1131 unsafe impl fidl::encoding::TypeMarker for BootstrapError {
1132 type Owned = Self;
1133
1134 #[inline(always)]
1135 fn inline_align(_context: fidl::encoding::Context) -> usize {
1136 std::mem::align_of::<u32>()
1137 }
1138
1139 #[inline(always)]
1140 fn inline_size(_context: fidl::encoding::Context) -> usize {
1141 std::mem::size_of::<u32>()
1142 }
1143
1144 #[inline(always)]
1145 fn encode_is_copy() -> bool {
1146 true
1147 }
1148
1149 #[inline(always)]
1150 fn decode_is_copy() -> bool {
1151 false
1152 }
1153 }
1154
1155 impl fidl::encoding::ValueTypeMarker for BootstrapError {
1156 type Borrowed<'a> = Self;
1157 #[inline(always)]
1158 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1159 *value
1160 }
1161 }
1162
1163 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BootstrapError {
1164 #[inline]
1165 unsafe fn encode(
1166 self,
1167 encoder: &mut fidl::encoding::Encoder<'_, D>,
1168 offset: usize,
1169 _depth: fidl::encoding::Depth,
1170 ) -> fidl::Result<()> {
1171 encoder.debug_check_bounds::<Self>(offset);
1172 encoder.write_num(self.into_primitive(), offset);
1173 Ok(())
1174 }
1175 }
1176
1177 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BootstrapError {
1178 #[inline(always)]
1179 fn new_empty() -> Self {
1180 Self::InvalidHostIdentity
1181 }
1182
1183 #[inline]
1184 unsafe fn decode(
1185 &mut self,
1186 decoder: &mut fidl::encoding::Decoder<'_, D>,
1187 offset: usize,
1188 _depth: fidl::encoding::Depth,
1189 ) -> fidl::Result<()> {
1190 decoder.debug_check_bounds::<Self>(offset);
1191 let prim = decoder.read_num::<u32>(offset);
1192
1193 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1194 Ok(())
1195 }
1196 }
1197 unsafe impl fidl::encoding::TypeMarker for BrEdrSecurityMode {
1198 type Owned = Self;
1199
1200 #[inline(always)]
1201 fn inline_align(_context: fidl::encoding::Context) -> usize {
1202 std::mem::align_of::<u32>()
1203 }
1204
1205 #[inline(always)]
1206 fn inline_size(_context: fidl::encoding::Context) -> usize {
1207 std::mem::size_of::<u32>()
1208 }
1209
1210 #[inline(always)]
1211 fn encode_is_copy() -> bool {
1212 true
1213 }
1214
1215 #[inline(always)]
1216 fn decode_is_copy() -> bool {
1217 false
1218 }
1219 }
1220
1221 impl fidl::encoding::ValueTypeMarker for BrEdrSecurityMode {
1222 type Borrowed<'a> = Self;
1223 #[inline(always)]
1224 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1225 *value
1226 }
1227 }
1228
1229 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1230 for BrEdrSecurityMode
1231 {
1232 #[inline]
1233 unsafe fn encode(
1234 self,
1235 encoder: &mut fidl::encoding::Encoder<'_, D>,
1236 offset: usize,
1237 _depth: fidl::encoding::Depth,
1238 ) -> fidl::Result<()> {
1239 encoder.debug_check_bounds::<Self>(offset);
1240 encoder.write_num(self.into_primitive(), offset);
1241 Ok(())
1242 }
1243 }
1244
1245 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BrEdrSecurityMode {
1246 #[inline(always)]
1247 fn new_empty() -> Self {
1248 Self::Mode4
1249 }
1250
1251 #[inline]
1252 unsafe fn decode(
1253 &mut self,
1254 decoder: &mut fidl::encoding::Decoder<'_, D>,
1255 offset: usize,
1256 _depth: fidl::encoding::Depth,
1257 ) -> fidl::Result<()> {
1258 decoder.debug_check_bounds::<Self>(offset);
1259 let prim = decoder.read_num::<u32>(offset);
1260
1261 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1262 Ok(())
1263 }
1264 }
1265 unsafe impl fidl::encoding::TypeMarker for Error {
1266 type Owned = Self;
1267
1268 #[inline(always)]
1269 fn inline_align(_context: fidl::encoding::Context) -> usize {
1270 std::mem::align_of::<u32>()
1271 }
1272
1273 #[inline(always)]
1274 fn inline_size(_context: fidl::encoding::Context) -> usize {
1275 std::mem::size_of::<u32>()
1276 }
1277
1278 #[inline(always)]
1279 fn encode_is_copy() -> bool {
1280 true
1281 }
1282
1283 #[inline(always)]
1284 fn decode_is_copy() -> bool {
1285 false
1286 }
1287 }
1288
1289 impl fidl::encoding::ValueTypeMarker for Error {
1290 type Borrowed<'a> = Self;
1291 #[inline(always)]
1292 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1293 *value
1294 }
1295 }
1296
1297 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
1298 #[inline]
1299 unsafe fn encode(
1300 self,
1301 encoder: &mut fidl::encoding::Encoder<'_, D>,
1302 offset: usize,
1303 _depth: fidl::encoding::Depth,
1304 ) -> fidl::Result<()> {
1305 encoder.debug_check_bounds::<Self>(offset);
1306 encoder.write_num(self.into_primitive(), offset);
1307 Ok(())
1308 }
1309 }
1310
1311 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
1312 #[inline(always)]
1313 fn new_empty() -> Self {
1314 Self::Failed
1315 }
1316
1317 #[inline]
1318 unsafe fn decode(
1319 &mut self,
1320 decoder: &mut fidl::encoding::Decoder<'_, D>,
1321 offset: usize,
1322 _depth: fidl::encoding::Depth,
1323 ) -> fidl::Result<()> {
1324 decoder.debug_check_bounds::<Self>(offset);
1325 let prim = decoder.read_num::<u32>(offset);
1326
1327 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1328 Ok(())
1329 }
1330 }
1331 unsafe impl fidl::encoding::TypeMarker for InputCapability {
1332 type Owned = Self;
1333
1334 #[inline(always)]
1335 fn inline_align(_context: fidl::encoding::Context) -> usize {
1336 std::mem::align_of::<u32>()
1337 }
1338
1339 #[inline(always)]
1340 fn inline_size(_context: fidl::encoding::Context) -> usize {
1341 std::mem::size_of::<u32>()
1342 }
1343
1344 #[inline(always)]
1345 fn encode_is_copy() -> bool {
1346 true
1347 }
1348
1349 #[inline(always)]
1350 fn decode_is_copy() -> bool {
1351 false
1352 }
1353 }
1354
1355 impl fidl::encoding::ValueTypeMarker for InputCapability {
1356 type Borrowed<'a> = Self;
1357 #[inline(always)]
1358 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1359 *value
1360 }
1361 }
1362
1363 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1364 for InputCapability
1365 {
1366 #[inline]
1367 unsafe fn encode(
1368 self,
1369 encoder: &mut fidl::encoding::Encoder<'_, D>,
1370 offset: usize,
1371 _depth: fidl::encoding::Depth,
1372 ) -> fidl::Result<()> {
1373 encoder.debug_check_bounds::<Self>(offset);
1374 encoder.write_num(self.into_primitive(), offset);
1375 Ok(())
1376 }
1377 }
1378
1379 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InputCapability {
1380 #[inline(always)]
1381 fn new_empty() -> Self {
1382 Self::None
1383 }
1384
1385 #[inline]
1386 unsafe fn decode(
1387 &mut self,
1388 decoder: &mut fidl::encoding::Decoder<'_, D>,
1389 offset: usize,
1390 _depth: fidl::encoding::Depth,
1391 ) -> fidl::Result<()> {
1392 decoder.debug_check_bounds::<Self>(offset);
1393 let prim = decoder.read_num::<u32>(offset);
1394
1395 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1396 Ok(())
1397 }
1398 }
1399 unsafe impl fidl::encoding::TypeMarker for LeSecurityMode {
1400 type Owned = Self;
1401
1402 #[inline(always)]
1403 fn inline_align(_context: fidl::encoding::Context) -> usize {
1404 std::mem::align_of::<u32>()
1405 }
1406
1407 #[inline(always)]
1408 fn inline_size(_context: fidl::encoding::Context) -> usize {
1409 std::mem::size_of::<u32>()
1410 }
1411
1412 #[inline(always)]
1413 fn encode_is_copy() -> bool {
1414 true
1415 }
1416
1417 #[inline(always)]
1418 fn decode_is_copy() -> bool {
1419 false
1420 }
1421 }
1422
1423 impl fidl::encoding::ValueTypeMarker for LeSecurityMode {
1424 type Borrowed<'a> = Self;
1425 #[inline(always)]
1426 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1427 *value
1428 }
1429 }
1430
1431 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LeSecurityMode {
1432 #[inline]
1433 unsafe fn encode(
1434 self,
1435 encoder: &mut fidl::encoding::Encoder<'_, D>,
1436 offset: usize,
1437 _depth: fidl::encoding::Depth,
1438 ) -> fidl::Result<()> {
1439 encoder.debug_check_bounds::<Self>(offset);
1440 encoder.write_num(self.into_primitive(), offset);
1441 Ok(())
1442 }
1443 }
1444
1445 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeSecurityMode {
1446 #[inline(always)]
1447 fn new_empty() -> Self {
1448 Self::Mode1
1449 }
1450
1451 #[inline]
1452 unsafe fn decode(
1453 &mut self,
1454 decoder: &mut fidl::encoding::Decoder<'_, D>,
1455 offset: usize,
1456 _depth: fidl::encoding::Depth,
1457 ) -> fidl::Result<()> {
1458 decoder.debug_check_bounds::<Self>(offset);
1459 let prim = decoder.read_num::<u32>(offset);
1460
1461 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1462 Ok(())
1463 }
1464 }
1465 unsafe impl fidl::encoding::TypeMarker for LookupError {
1466 type Owned = Self;
1467
1468 #[inline(always)]
1469 fn inline_align(_context: fidl::encoding::Context) -> usize {
1470 std::mem::align_of::<u32>()
1471 }
1472
1473 #[inline(always)]
1474 fn inline_size(_context: fidl::encoding::Context) -> usize {
1475 std::mem::size_of::<u32>()
1476 }
1477
1478 #[inline(always)]
1479 fn encode_is_copy() -> bool {
1480 false
1481 }
1482
1483 #[inline(always)]
1484 fn decode_is_copy() -> bool {
1485 false
1486 }
1487 }
1488
1489 impl fidl::encoding::ValueTypeMarker for LookupError {
1490 type Borrowed<'a> = Self;
1491 #[inline(always)]
1492 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1493 *value
1494 }
1495 }
1496
1497 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LookupError {
1498 #[inline]
1499 unsafe fn encode(
1500 self,
1501 encoder: &mut fidl::encoding::Encoder<'_, D>,
1502 offset: usize,
1503 _depth: fidl::encoding::Depth,
1504 ) -> fidl::Result<()> {
1505 encoder.debug_check_bounds::<Self>(offset);
1506 encoder.write_num(self.into_primitive(), offset);
1507 Ok(())
1508 }
1509 }
1510
1511 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LookupError {
1512 #[inline(always)]
1513 fn new_empty() -> Self {
1514 Self::unknown()
1515 }
1516
1517 #[inline]
1518 unsafe fn decode(
1519 &mut self,
1520 decoder: &mut fidl::encoding::Decoder<'_, D>,
1521 offset: usize,
1522 _depth: fidl::encoding::Depth,
1523 ) -> fidl::Result<()> {
1524 decoder.debug_check_bounds::<Self>(offset);
1525 let prim = decoder.read_num::<u32>(offset);
1526
1527 *self = Self::from_primitive_allow_unknown(prim);
1528 Ok(())
1529 }
1530 }
1531 unsafe impl fidl::encoding::TypeMarker for OutputCapability {
1532 type Owned = Self;
1533
1534 #[inline(always)]
1535 fn inline_align(_context: fidl::encoding::Context) -> usize {
1536 std::mem::align_of::<u32>()
1537 }
1538
1539 #[inline(always)]
1540 fn inline_size(_context: fidl::encoding::Context) -> usize {
1541 std::mem::size_of::<u32>()
1542 }
1543
1544 #[inline(always)]
1545 fn encode_is_copy() -> bool {
1546 true
1547 }
1548
1549 #[inline(always)]
1550 fn decode_is_copy() -> bool {
1551 false
1552 }
1553 }
1554
1555 impl fidl::encoding::ValueTypeMarker for OutputCapability {
1556 type Borrowed<'a> = Self;
1557 #[inline(always)]
1558 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1559 *value
1560 }
1561 }
1562
1563 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1564 for OutputCapability
1565 {
1566 #[inline]
1567 unsafe fn encode(
1568 self,
1569 encoder: &mut fidl::encoding::Encoder<'_, D>,
1570 offset: usize,
1571 _depth: fidl::encoding::Depth,
1572 ) -> fidl::Result<()> {
1573 encoder.debug_check_bounds::<Self>(offset);
1574 encoder.write_num(self.into_primitive(), offset);
1575 Ok(())
1576 }
1577 }
1578
1579 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OutputCapability {
1580 #[inline(always)]
1581 fn new_empty() -> Self {
1582 Self::None
1583 }
1584
1585 #[inline]
1586 unsafe fn decode(
1587 &mut self,
1588 decoder: &mut fidl::encoding::Decoder<'_, D>,
1589 offset: usize,
1590 _depth: fidl::encoding::Depth,
1591 ) -> fidl::Result<()> {
1592 decoder.debug_check_bounds::<Self>(offset);
1593 let prim = decoder.read_num::<u32>(offset);
1594
1595 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1596 Ok(())
1597 }
1598 }
1599 unsafe impl fidl::encoding::TypeMarker for PairingKeypress {
1600 type Owned = Self;
1601
1602 #[inline(always)]
1603 fn inline_align(_context: fidl::encoding::Context) -> usize {
1604 std::mem::align_of::<u32>()
1605 }
1606
1607 #[inline(always)]
1608 fn inline_size(_context: fidl::encoding::Context) -> usize {
1609 std::mem::size_of::<u32>()
1610 }
1611
1612 #[inline(always)]
1613 fn encode_is_copy() -> bool {
1614 true
1615 }
1616
1617 #[inline(always)]
1618 fn decode_is_copy() -> bool {
1619 false
1620 }
1621 }
1622
1623 impl fidl::encoding::ValueTypeMarker for PairingKeypress {
1624 type Borrowed<'a> = Self;
1625 #[inline(always)]
1626 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1627 *value
1628 }
1629 }
1630
1631 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1632 for PairingKeypress
1633 {
1634 #[inline]
1635 unsafe fn encode(
1636 self,
1637 encoder: &mut fidl::encoding::Encoder<'_, D>,
1638 offset: usize,
1639 _depth: fidl::encoding::Depth,
1640 ) -> fidl::Result<()> {
1641 encoder.debug_check_bounds::<Self>(offset);
1642 encoder.write_num(self.into_primitive(), offset);
1643 Ok(())
1644 }
1645 }
1646
1647 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PairingKeypress {
1648 #[inline(always)]
1649 fn new_empty() -> Self {
1650 Self::DigitEntered
1651 }
1652
1653 #[inline]
1654 unsafe fn decode(
1655 &mut self,
1656 decoder: &mut fidl::encoding::Decoder<'_, D>,
1657 offset: usize,
1658 _depth: fidl::encoding::Depth,
1659 ) -> fidl::Result<()> {
1660 decoder.debug_check_bounds::<Self>(offset);
1661 let prim = decoder.read_num::<u32>(offset);
1662
1663 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1664 Ok(())
1665 }
1666 }
1667 unsafe impl fidl::encoding::TypeMarker for PairingMethod {
1668 type Owned = Self;
1669
1670 #[inline(always)]
1671 fn inline_align(_context: fidl::encoding::Context) -> usize {
1672 std::mem::align_of::<u32>()
1673 }
1674
1675 #[inline(always)]
1676 fn inline_size(_context: fidl::encoding::Context) -> usize {
1677 std::mem::size_of::<u32>()
1678 }
1679
1680 #[inline(always)]
1681 fn encode_is_copy() -> bool {
1682 true
1683 }
1684
1685 #[inline(always)]
1686 fn decode_is_copy() -> bool {
1687 false
1688 }
1689 }
1690
1691 impl fidl::encoding::ValueTypeMarker for PairingMethod {
1692 type Borrowed<'a> = Self;
1693 #[inline(always)]
1694 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1695 *value
1696 }
1697 }
1698
1699 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PairingMethod {
1700 #[inline]
1701 unsafe fn encode(
1702 self,
1703 encoder: &mut fidl::encoding::Encoder<'_, D>,
1704 offset: usize,
1705 _depth: fidl::encoding::Depth,
1706 ) -> fidl::Result<()> {
1707 encoder.debug_check_bounds::<Self>(offset);
1708 encoder.write_num(self.into_primitive(), offset);
1709 Ok(())
1710 }
1711 }
1712
1713 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PairingMethod {
1714 #[inline(always)]
1715 fn new_empty() -> Self {
1716 Self::Consent
1717 }
1718
1719 #[inline]
1720 unsafe fn decode(
1721 &mut self,
1722 decoder: &mut fidl::encoding::Decoder<'_, D>,
1723 offset: usize,
1724 _depth: fidl::encoding::Depth,
1725 ) -> fidl::Result<()> {
1726 decoder.debug_check_bounds::<Self>(offset);
1727 let prim = decoder.read_num::<u32>(offset);
1728
1729 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1730 Ok(())
1731 }
1732 }
1733 unsafe impl fidl::encoding::TypeMarker for PairingSecurityLevel {
1734 type Owned = Self;
1735
1736 #[inline(always)]
1737 fn inline_align(_context: fidl::encoding::Context) -> usize {
1738 std::mem::align_of::<u32>()
1739 }
1740
1741 #[inline(always)]
1742 fn inline_size(_context: fidl::encoding::Context) -> usize {
1743 std::mem::size_of::<u32>()
1744 }
1745
1746 #[inline(always)]
1747 fn encode_is_copy() -> bool {
1748 true
1749 }
1750
1751 #[inline(always)]
1752 fn decode_is_copy() -> bool {
1753 false
1754 }
1755 }
1756
1757 impl fidl::encoding::ValueTypeMarker for PairingSecurityLevel {
1758 type Borrowed<'a> = Self;
1759 #[inline(always)]
1760 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1761 *value
1762 }
1763 }
1764
1765 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1766 for PairingSecurityLevel
1767 {
1768 #[inline]
1769 unsafe fn encode(
1770 self,
1771 encoder: &mut fidl::encoding::Encoder<'_, D>,
1772 offset: usize,
1773 _depth: fidl::encoding::Depth,
1774 ) -> fidl::Result<()> {
1775 encoder.debug_check_bounds::<Self>(offset);
1776 encoder.write_num(self.into_primitive(), offset);
1777 Ok(())
1778 }
1779 }
1780
1781 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PairingSecurityLevel {
1782 #[inline(always)]
1783 fn new_empty() -> Self {
1784 Self::Encrypted
1785 }
1786
1787 #[inline]
1788 unsafe fn decode(
1789 &mut self,
1790 decoder: &mut fidl::encoding::Decoder<'_, D>,
1791 offset: usize,
1792 _depth: fidl::encoding::Depth,
1793 ) -> fidl::Result<()> {
1794 decoder.debug_check_bounds::<Self>(offset);
1795 let prim = decoder.read_num::<u32>(offset);
1796
1797 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1798 Ok(())
1799 }
1800 }
1801 unsafe impl fidl::encoding::TypeMarker for TechnologyType {
1802 type Owned = Self;
1803
1804 #[inline(always)]
1805 fn inline_align(_context: fidl::encoding::Context) -> usize {
1806 std::mem::align_of::<u32>()
1807 }
1808
1809 #[inline(always)]
1810 fn inline_size(_context: fidl::encoding::Context) -> usize {
1811 std::mem::size_of::<u32>()
1812 }
1813
1814 #[inline(always)]
1815 fn encode_is_copy() -> bool {
1816 true
1817 }
1818
1819 #[inline(always)]
1820 fn decode_is_copy() -> bool {
1821 false
1822 }
1823 }
1824
1825 impl fidl::encoding::ValueTypeMarker for TechnologyType {
1826 type Borrowed<'a> = Self;
1827 #[inline(always)]
1828 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1829 *value
1830 }
1831 }
1832
1833 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TechnologyType {
1834 #[inline]
1835 unsafe fn encode(
1836 self,
1837 encoder: &mut fidl::encoding::Encoder<'_, D>,
1838 offset: usize,
1839 _depth: fidl::encoding::Depth,
1840 ) -> fidl::Result<()> {
1841 encoder.debug_check_bounds::<Self>(offset);
1842 encoder.write_num(self.into_primitive(), offset);
1843 Ok(())
1844 }
1845 }
1846
1847 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TechnologyType {
1848 #[inline(always)]
1849 fn new_empty() -> Self {
1850 Self::LowEnergy
1851 }
1852
1853 #[inline]
1854 unsafe fn decode(
1855 &mut self,
1856 decoder: &mut fidl::encoding::Decoder<'_, D>,
1857 offset: usize,
1858 _depth: fidl::encoding::Depth,
1859 ) -> fidl::Result<()> {
1860 decoder.debug_check_bounds::<Self>(offset);
1861 let prim = decoder.read_num::<u32>(offset);
1862
1863 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1864 Ok(())
1865 }
1866 }
1867
1868 impl fidl::encoding::ValueTypeMarker for AccessConnectRequest {
1869 type Borrowed<'a> = &'a Self;
1870 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1871 value
1872 }
1873 }
1874
1875 unsafe impl fidl::encoding::TypeMarker for AccessConnectRequest {
1876 type Owned = Self;
1877
1878 #[inline(always)]
1879 fn inline_align(_context: fidl::encoding::Context) -> usize {
1880 8
1881 }
1882
1883 #[inline(always)]
1884 fn inline_size(_context: fidl::encoding::Context) -> usize {
1885 8
1886 }
1887 }
1888
1889 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AccessConnectRequest, D>
1890 for &AccessConnectRequest
1891 {
1892 #[inline]
1893 unsafe fn encode(
1894 self,
1895 encoder: &mut fidl::encoding::Encoder<'_, D>,
1896 offset: usize,
1897 _depth: fidl::encoding::Depth,
1898 ) -> fidl::Result<()> {
1899 encoder.debug_check_bounds::<AccessConnectRequest>(offset);
1900 fidl::encoding::Encode::<AccessConnectRequest, D>::encode(
1902 (
1903 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
1904 ),
1905 encoder, offset, _depth
1906 )
1907 }
1908 }
1909 unsafe impl<
1910 D: fidl::encoding::ResourceDialect,
1911 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
1912 > fidl::encoding::Encode<AccessConnectRequest, D> for (T0,)
1913 {
1914 #[inline]
1915 unsafe fn encode(
1916 self,
1917 encoder: &mut fidl::encoding::Encoder<'_, D>,
1918 offset: usize,
1919 depth: fidl::encoding::Depth,
1920 ) -> fidl::Result<()> {
1921 encoder.debug_check_bounds::<AccessConnectRequest>(offset);
1922 self.0.encode(encoder, offset + 0, depth)?;
1926 Ok(())
1927 }
1928 }
1929
1930 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AccessConnectRequest {
1931 #[inline(always)]
1932 fn new_empty() -> Self {
1933 Self { id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D) }
1934 }
1935
1936 #[inline]
1937 unsafe fn decode(
1938 &mut self,
1939 decoder: &mut fidl::encoding::Decoder<'_, D>,
1940 offset: usize,
1941 _depth: fidl::encoding::Depth,
1942 ) -> fidl::Result<()> {
1943 decoder.debug_check_bounds::<Self>(offset);
1944 fidl::decode!(
1946 fidl_fuchsia_bluetooth__common::PeerId,
1947 D,
1948 &mut self.id,
1949 decoder,
1950 offset + 0,
1951 _depth
1952 )?;
1953 Ok(())
1954 }
1955 }
1956
1957 impl fidl::encoding::ValueTypeMarker for AccessDisconnectRequest {
1958 type Borrowed<'a> = &'a Self;
1959 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1960 value
1961 }
1962 }
1963
1964 unsafe impl fidl::encoding::TypeMarker for AccessDisconnectRequest {
1965 type Owned = Self;
1966
1967 #[inline(always)]
1968 fn inline_align(_context: fidl::encoding::Context) -> usize {
1969 8
1970 }
1971
1972 #[inline(always)]
1973 fn inline_size(_context: fidl::encoding::Context) -> usize {
1974 8
1975 }
1976 }
1977
1978 unsafe impl<D: fidl::encoding::ResourceDialect>
1979 fidl::encoding::Encode<AccessDisconnectRequest, D> for &AccessDisconnectRequest
1980 {
1981 #[inline]
1982 unsafe fn encode(
1983 self,
1984 encoder: &mut fidl::encoding::Encoder<'_, D>,
1985 offset: usize,
1986 _depth: fidl::encoding::Depth,
1987 ) -> fidl::Result<()> {
1988 encoder.debug_check_bounds::<AccessDisconnectRequest>(offset);
1989 fidl::encoding::Encode::<AccessDisconnectRequest, D>::encode(
1991 (
1992 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
1993 ),
1994 encoder, offset, _depth
1995 )
1996 }
1997 }
1998 unsafe impl<
1999 D: fidl::encoding::ResourceDialect,
2000 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2001 > fidl::encoding::Encode<AccessDisconnectRequest, D> for (T0,)
2002 {
2003 #[inline]
2004 unsafe fn encode(
2005 self,
2006 encoder: &mut fidl::encoding::Encoder<'_, D>,
2007 offset: usize,
2008 depth: fidl::encoding::Depth,
2009 ) -> fidl::Result<()> {
2010 encoder.debug_check_bounds::<AccessDisconnectRequest>(offset);
2011 self.0.encode(encoder, offset + 0, depth)?;
2015 Ok(())
2016 }
2017 }
2018
2019 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2020 for AccessDisconnectRequest
2021 {
2022 #[inline(always)]
2023 fn new_empty() -> Self {
2024 Self { id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D) }
2025 }
2026
2027 #[inline]
2028 unsafe fn decode(
2029 &mut self,
2030 decoder: &mut fidl::encoding::Decoder<'_, D>,
2031 offset: usize,
2032 _depth: fidl::encoding::Depth,
2033 ) -> fidl::Result<()> {
2034 decoder.debug_check_bounds::<Self>(offset);
2035 fidl::decode!(
2037 fidl_fuchsia_bluetooth__common::PeerId,
2038 D,
2039 &mut self.id,
2040 decoder,
2041 offset + 0,
2042 _depth
2043 )?;
2044 Ok(())
2045 }
2046 }
2047
2048 impl fidl::encoding::ValueTypeMarker for AccessForgetRequest {
2049 type Borrowed<'a> = &'a Self;
2050 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2051 value
2052 }
2053 }
2054
2055 unsafe impl fidl::encoding::TypeMarker for AccessForgetRequest {
2056 type Owned = Self;
2057
2058 #[inline(always)]
2059 fn inline_align(_context: fidl::encoding::Context) -> usize {
2060 8
2061 }
2062
2063 #[inline(always)]
2064 fn inline_size(_context: fidl::encoding::Context) -> usize {
2065 8
2066 }
2067 }
2068
2069 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AccessForgetRequest, D>
2070 for &AccessForgetRequest
2071 {
2072 #[inline]
2073 unsafe fn encode(
2074 self,
2075 encoder: &mut fidl::encoding::Encoder<'_, D>,
2076 offset: usize,
2077 _depth: fidl::encoding::Depth,
2078 ) -> fidl::Result<()> {
2079 encoder.debug_check_bounds::<AccessForgetRequest>(offset);
2080 fidl::encoding::Encode::<AccessForgetRequest, D>::encode(
2082 (
2083 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
2084 ),
2085 encoder, offset, _depth
2086 )
2087 }
2088 }
2089 unsafe impl<
2090 D: fidl::encoding::ResourceDialect,
2091 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2092 > fidl::encoding::Encode<AccessForgetRequest, D> for (T0,)
2093 {
2094 #[inline]
2095 unsafe fn encode(
2096 self,
2097 encoder: &mut fidl::encoding::Encoder<'_, D>,
2098 offset: usize,
2099 depth: fidl::encoding::Depth,
2100 ) -> fidl::Result<()> {
2101 encoder.debug_check_bounds::<AccessForgetRequest>(offset);
2102 self.0.encode(encoder, offset + 0, depth)?;
2106 Ok(())
2107 }
2108 }
2109
2110 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AccessForgetRequest {
2111 #[inline(always)]
2112 fn new_empty() -> Self {
2113 Self { id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D) }
2114 }
2115
2116 #[inline]
2117 unsafe fn decode(
2118 &mut self,
2119 decoder: &mut fidl::encoding::Decoder<'_, D>,
2120 offset: usize,
2121 _depth: fidl::encoding::Depth,
2122 ) -> fidl::Result<()> {
2123 decoder.debug_check_bounds::<Self>(offset);
2124 fidl::decode!(
2126 fidl_fuchsia_bluetooth__common::PeerId,
2127 D,
2128 &mut self.id,
2129 decoder,
2130 offset + 0,
2131 _depth
2132 )?;
2133 Ok(())
2134 }
2135 }
2136
2137 impl fidl::encoding::ValueTypeMarker for AccessPairRequest {
2138 type Borrowed<'a> = &'a Self;
2139 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2140 value
2141 }
2142 }
2143
2144 unsafe impl fidl::encoding::TypeMarker for AccessPairRequest {
2145 type Owned = Self;
2146
2147 #[inline(always)]
2148 fn inline_align(_context: fidl::encoding::Context) -> usize {
2149 8
2150 }
2151
2152 #[inline(always)]
2153 fn inline_size(_context: fidl::encoding::Context) -> usize {
2154 24
2155 }
2156 }
2157
2158 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AccessPairRequest, D>
2159 for &AccessPairRequest
2160 {
2161 #[inline]
2162 unsafe fn encode(
2163 self,
2164 encoder: &mut fidl::encoding::Encoder<'_, D>,
2165 offset: usize,
2166 _depth: fidl::encoding::Depth,
2167 ) -> fidl::Result<()> {
2168 encoder.debug_check_bounds::<AccessPairRequest>(offset);
2169 fidl::encoding::Encode::<AccessPairRequest, D>::encode(
2171 (
2172 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
2173 <PairingOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2174 ),
2175 encoder, offset, _depth
2176 )
2177 }
2178 }
2179 unsafe impl<
2180 D: fidl::encoding::ResourceDialect,
2181 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
2182 T1: fidl::encoding::Encode<PairingOptions, D>,
2183 > fidl::encoding::Encode<AccessPairRequest, D> for (T0, T1)
2184 {
2185 #[inline]
2186 unsafe fn encode(
2187 self,
2188 encoder: &mut fidl::encoding::Encoder<'_, D>,
2189 offset: usize,
2190 depth: fidl::encoding::Depth,
2191 ) -> fidl::Result<()> {
2192 encoder.debug_check_bounds::<AccessPairRequest>(offset);
2193 self.0.encode(encoder, offset + 0, depth)?;
2197 self.1.encode(encoder, offset + 8, depth)?;
2198 Ok(())
2199 }
2200 }
2201
2202 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AccessPairRequest {
2203 #[inline(always)]
2204 fn new_empty() -> Self {
2205 Self {
2206 id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
2207 options: fidl::new_empty!(PairingOptions, D),
2208 }
2209 }
2210
2211 #[inline]
2212 unsafe fn decode(
2213 &mut self,
2214 decoder: &mut fidl::encoding::Decoder<'_, D>,
2215 offset: usize,
2216 _depth: fidl::encoding::Depth,
2217 ) -> fidl::Result<()> {
2218 decoder.debug_check_bounds::<Self>(offset);
2219 fidl::decode!(
2221 fidl_fuchsia_bluetooth__common::PeerId,
2222 D,
2223 &mut self.id,
2224 decoder,
2225 offset + 0,
2226 _depth
2227 )?;
2228 fidl::decode!(PairingOptions, D, &mut self.options, decoder, offset + 8, _depth)?;
2229 Ok(())
2230 }
2231 }
2232
2233 impl fidl::encoding::ValueTypeMarker for AccessSetDeviceClassRequest {
2234 type Borrowed<'a> = &'a Self;
2235 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2236 value
2237 }
2238 }
2239
2240 unsafe impl fidl::encoding::TypeMarker for AccessSetDeviceClassRequest {
2241 type Owned = Self;
2242
2243 #[inline(always)]
2244 fn inline_align(_context: fidl::encoding::Context) -> usize {
2245 4
2246 }
2247
2248 #[inline(always)]
2249 fn inline_size(_context: fidl::encoding::Context) -> usize {
2250 4
2251 }
2252 }
2253
2254 unsafe impl<D: fidl::encoding::ResourceDialect>
2255 fidl::encoding::Encode<AccessSetDeviceClassRequest, D> for &AccessSetDeviceClassRequest
2256 {
2257 #[inline]
2258 unsafe fn encode(
2259 self,
2260 encoder: &mut fidl::encoding::Encoder<'_, D>,
2261 offset: usize,
2262 _depth: fidl::encoding::Depth,
2263 ) -> fidl::Result<()> {
2264 encoder.debug_check_bounds::<AccessSetDeviceClassRequest>(offset);
2265 fidl::encoding::Encode::<AccessSetDeviceClassRequest, D>::encode(
2267 (
2268 <fidl_fuchsia_bluetooth__common::DeviceClass as fidl::encoding::ValueTypeMarker>::borrow(&self.device_class),
2269 ),
2270 encoder, offset, _depth
2271 )
2272 }
2273 }
2274 unsafe impl<
2275 D: fidl::encoding::ResourceDialect,
2276 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::DeviceClass, D>,
2277 > fidl::encoding::Encode<AccessSetDeviceClassRequest, D> for (T0,)
2278 {
2279 #[inline]
2280 unsafe fn encode(
2281 self,
2282 encoder: &mut fidl::encoding::Encoder<'_, D>,
2283 offset: usize,
2284 depth: fidl::encoding::Depth,
2285 ) -> fidl::Result<()> {
2286 encoder.debug_check_bounds::<AccessSetDeviceClassRequest>(offset);
2287 self.0.encode(encoder, offset + 0, depth)?;
2291 Ok(())
2292 }
2293 }
2294
2295 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2296 for AccessSetDeviceClassRequest
2297 {
2298 #[inline(always)]
2299 fn new_empty() -> Self {
2300 Self { device_class: fidl::new_empty!(fidl_fuchsia_bluetooth__common::DeviceClass, D) }
2301 }
2302
2303 #[inline]
2304 unsafe fn decode(
2305 &mut self,
2306 decoder: &mut fidl::encoding::Decoder<'_, D>,
2307 offset: usize,
2308 _depth: fidl::encoding::Depth,
2309 ) -> fidl::Result<()> {
2310 decoder.debug_check_bounds::<Self>(offset);
2311 fidl::decode!(
2313 fidl_fuchsia_bluetooth__common::DeviceClass,
2314 D,
2315 &mut self.device_class,
2316 decoder,
2317 offset + 0,
2318 _depth
2319 )?;
2320 Ok(())
2321 }
2322 }
2323
2324 impl fidl::encoding::ValueTypeMarker for AccessSetLocalNameRequest {
2325 type Borrowed<'a> = &'a Self;
2326 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2327 value
2328 }
2329 }
2330
2331 unsafe impl fidl::encoding::TypeMarker for AccessSetLocalNameRequest {
2332 type Owned = Self;
2333
2334 #[inline(always)]
2335 fn inline_align(_context: fidl::encoding::Context) -> usize {
2336 8
2337 }
2338
2339 #[inline(always)]
2340 fn inline_size(_context: fidl::encoding::Context) -> usize {
2341 16
2342 }
2343 }
2344
2345 unsafe impl<D: fidl::encoding::ResourceDialect>
2346 fidl::encoding::Encode<AccessSetLocalNameRequest, D> for &AccessSetLocalNameRequest
2347 {
2348 #[inline]
2349 unsafe fn encode(
2350 self,
2351 encoder: &mut fidl::encoding::Encoder<'_, D>,
2352 offset: usize,
2353 _depth: fidl::encoding::Depth,
2354 ) -> fidl::Result<()> {
2355 encoder.debug_check_bounds::<AccessSetLocalNameRequest>(offset);
2356 fidl::encoding::Encode::<AccessSetLocalNameRequest, D>::encode(
2358 (<fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow(
2359 &self.name,
2360 ),),
2361 encoder,
2362 offset,
2363 _depth,
2364 )
2365 }
2366 }
2367 unsafe impl<
2368 D: fidl::encoding::ResourceDialect,
2369 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<248>, D>,
2370 > fidl::encoding::Encode<AccessSetLocalNameRequest, D> for (T0,)
2371 {
2372 #[inline]
2373 unsafe fn encode(
2374 self,
2375 encoder: &mut fidl::encoding::Encoder<'_, D>,
2376 offset: usize,
2377 depth: fidl::encoding::Depth,
2378 ) -> fidl::Result<()> {
2379 encoder.debug_check_bounds::<AccessSetLocalNameRequest>(offset);
2380 self.0.encode(encoder, offset + 0, depth)?;
2384 Ok(())
2385 }
2386 }
2387
2388 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2389 for AccessSetLocalNameRequest
2390 {
2391 #[inline(always)]
2392 fn new_empty() -> Self {
2393 Self { name: fidl::new_empty!(fidl::encoding::BoundedString<248>, D) }
2394 }
2395
2396 #[inline]
2397 unsafe fn decode(
2398 &mut self,
2399 decoder: &mut fidl::encoding::Decoder<'_, D>,
2400 offset: usize,
2401 _depth: fidl::encoding::Depth,
2402 ) -> fidl::Result<()> {
2403 decoder.debug_check_bounds::<Self>(offset);
2404 fidl::decode!(
2406 fidl::encoding::BoundedString<248>,
2407 D,
2408 &mut self.name,
2409 decoder,
2410 offset + 0,
2411 _depth
2412 )?;
2413 Ok(())
2414 }
2415 }
2416
2417 impl fidl::encoding::ValueTypeMarker for AccessWatchPeersResponse {
2418 type Borrowed<'a> = &'a Self;
2419 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2420 value
2421 }
2422 }
2423
2424 unsafe impl fidl::encoding::TypeMarker for AccessWatchPeersResponse {
2425 type Owned = Self;
2426
2427 #[inline(always)]
2428 fn inline_align(_context: fidl::encoding::Context) -> usize {
2429 8
2430 }
2431
2432 #[inline(always)]
2433 fn inline_size(_context: fidl::encoding::Context) -> usize {
2434 32
2435 }
2436 }
2437
2438 unsafe impl<D: fidl::encoding::ResourceDialect>
2439 fidl::encoding::Encode<AccessWatchPeersResponse, D> for &AccessWatchPeersResponse
2440 {
2441 #[inline]
2442 unsafe fn encode(
2443 self,
2444 encoder: &mut fidl::encoding::Encoder<'_, D>,
2445 offset: usize,
2446 _depth: fidl::encoding::Depth,
2447 ) -> fidl::Result<()> {
2448 encoder.debug_check_bounds::<AccessWatchPeersResponse>(offset);
2449 fidl::encoding::Encode::<AccessWatchPeersResponse, D>::encode(
2451 (
2452 <fidl::encoding::UnboundedVector<Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.updated),
2453 <fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::PeerId> as fidl::encoding::ValueTypeMarker>::borrow(&self.removed),
2454 ),
2455 encoder, offset, _depth
2456 )
2457 }
2458 }
2459 unsafe impl<
2460 D: fidl::encoding::ResourceDialect,
2461 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Peer>, D>,
2462 T1: fidl::encoding::Encode<
2463 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::PeerId>,
2464 D,
2465 >,
2466 > fidl::encoding::Encode<AccessWatchPeersResponse, D> for (T0, T1)
2467 {
2468 #[inline]
2469 unsafe fn encode(
2470 self,
2471 encoder: &mut fidl::encoding::Encoder<'_, D>,
2472 offset: usize,
2473 depth: fidl::encoding::Depth,
2474 ) -> fidl::Result<()> {
2475 encoder.debug_check_bounds::<AccessWatchPeersResponse>(offset);
2476 self.0.encode(encoder, offset + 0, depth)?;
2480 self.1.encode(encoder, offset + 16, depth)?;
2481 Ok(())
2482 }
2483 }
2484
2485 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2486 for AccessWatchPeersResponse
2487 {
2488 #[inline(always)]
2489 fn new_empty() -> Self {
2490 Self {
2491 updated: fidl::new_empty!(fidl::encoding::UnboundedVector<Peer>, D),
2492 removed: fidl::new_empty!(
2493 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::PeerId>,
2494 D
2495 ),
2496 }
2497 }
2498
2499 #[inline]
2500 unsafe fn decode(
2501 &mut self,
2502 decoder: &mut fidl::encoding::Decoder<'_, D>,
2503 offset: usize,
2504 _depth: fidl::encoding::Depth,
2505 ) -> fidl::Result<()> {
2506 decoder.debug_check_bounds::<Self>(offset);
2507 fidl::decode!(
2509 fidl::encoding::UnboundedVector<Peer>,
2510 D,
2511 &mut self.updated,
2512 decoder,
2513 offset + 0,
2514 _depth
2515 )?;
2516 fidl::decode!(
2517 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::PeerId>,
2518 D,
2519 &mut self.removed,
2520 decoder,
2521 offset + 16,
2522 _depth
2523 )?;
2524 Ok(())
2525 }
2526 }
2527
2528 impl fidl::encoding::ValueTypeMarker for AddressLookupLookupResponse {
2529 type Borrowed<'a> = &'a Self;
2530 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2531 value
2532 }
2533 }
2534
2535 unsafe impl fidl::encoding::TypeMarker for AddressLookupLookupResponse {
2536 type Owned = Self;
2537
2538 #[inline(always)]
2539 fn inline_align(_context: fidl::encoding::Context) -> usize {
2540 1
2541 }
2542
2543 #[inline(always)]
2544 fn inline_size(_context: fidl::encoding::Context) -> usize {
2545 7
2546 }
2547 }
2548
2549 unsafe impl<D: fidl::encoding::ResourceDialect>
2550 fidl::encoding::Encode<AddressLookupLookupResponse, D> for &AddressLookupLookupResponse
2551 {
2552 #[inline]
2553 unsafe fn encode(
2554 self,
2555 encoder: &mut fidl::encoding::Encoder<'_, D>,
2556 offset: usize,
2557 _depth: fidl::encoding::Depth,
2558 ) -> fidl::Result<()> {
2559 encoder.debug_check_bounds::<AddressLookupLookupResponse>(offset);
2560 fidl::encoding::Encode::<AddressLookupLookupResponse, D>::encode(
2562 (
2563 <fidl_fuchsia_bluetooth__common::Address as fidl::encoding::ValueTypeMarker>::borrow(&self.bd_addr),
2564 ),
2565 encoder, offset, _depth
2566 )
2567 }
2568 }
2569 unsafe impl<
2570 D: fidl::encoding::ResourceDialect,
2571 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Address, D>,
2572 > fidl::encoding::Encode<AddressLookupLookupResponse, D> for (T0,)
2573 {
2574 #[inline]
2575 unsafe fn encode(
2576 self,
2577 encoder: &mut fidl::encoding::Encoder<'_, D>,
2578 offset: usize,
2579 depth: fidl::encoding::Depth,
2580 ) -> fidl::Result<()> {
2581 encoder.debug_check_bounds::<AddressLookupLookupResponse>(offset);
2582 self.0.encode(encoder, offset + 0, depth)?;
2586 Ok(())
2587 }
2588 }
2589
2590 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2591 for AddressLookupLookupResponse
2592 {
2593 #[inline(always)]
2594 fn new_empty() -> Self {
2595 Self { bd_addr: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Address, D) }
2596 }
2597
2598 #[inline]
2599 unsafe fn decode(
2600 &mut self,
2601 decoder: &mut fidl::encoding::Decoder<'_, D>,
2602 offset: usize,
2603 _depth: fidl::encoding::Depth,
2604 ) -> fidl::Result<()> {
2605 decoder.debug_check_bounds::<Self>(offset);
2606 fidl::decode!(
2608 fidl_fuchsia_bluetooth__common::Address,
2609 D,
2610 &mut self.bd_addr,
2611 decoder,
2612 offset + 0,
2613 _depth
2614 )?;
2615 Ok(())
2616 }
2617 }
2618
2619 impl fidl::encoding::ValueTypeMarker for BootstrapAddIdentitiesRequest {
2620 type Borrowed<'a> = &'a Self;
2621 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2622 value
2623 }
2624 }
2625
2626 unsafe impl fidl::encoding::TypeMarker for BootstrapAddIdentitiesRequest {
2627 type Owned = Self;
2628
2629 #[inline(always)]
2630 fn inline_align(_context: fidl::encoding::Context) -> usize {
2631 8
2632 }
2633
2634 #[inline(always)]
2635 fn inline_size(_context: fidl::encoding::Context) -> usize {
2636 16
2637 }
2638 }
2639
2640 unsafe impl<D: fidl::encoding::ResourceDialect>
2641 fidl::encoding::Encode<BootstrapAddIdentitiesRequest, D>
2642 for &BootstrapAddIdentitiesRequest
2643 {
2644 #[inline]
2645 unsafe fn encode(
2646 self,
2647 encoder: &mut fidl::encoding::Encoder<'_, D>,
2648 offset: usize,
2649 _depth: fidl::encoding::Depth,
2650 ) -> fidl::Result<()> {
2651 encoder.debug_check_bounds::<BootstrapAddIdentitiesRequest>(offset);
2652 fidl::encoding::Encode::<BootstrapAddIdentitiesRequest, D>::encode(
2654 (
2655 <fidl::encoding::UnboundedVector<Identity> as fidl::encoding::ValueTypeMarker>::borrow(&self.identities),
2656 ),
2657 encoder, offset, _depth
2658 )
2659 }
2660 }
2661 unsafe impl<
2662 D: fidl::encoding::ResourceDialect,
2663 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Identity>, D>,
2664 > fidl::encoding::Encode<BootstrapAddIdentitiesRequest, D> for (T0,)
2665 {
2666 #[inline]
2667 unsafe fn encode(
2668 self,
2669 encoder: &mut fidl::encoding::Encoder<'_, D>,
2670 offset: usize,
2671 depth: fidl::encoding::Depth,
2672 ) -> fidl::Result<()> {
2673 encoder.debug_check_bounds::<BootstrapAddIdentitiesRequest>(offset);
2674 self.0.encode(encoder, offset + 0, depth)?;
2678 Ok(())
2679 }
2680 }
2681
2682 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2683 for BootstrapAddIdentitiesRequest
2684 {
2685 #[inline(always)]
2686 fn new_empty() -> Self {
2687 Self { identities: fidl::new_empty!(fidl::encoding::UnboundedVector<Identity>, D) }
2688 }
2689
2690 #[inline]
2691 unsafe fn decode(
2692 &mut self,
2693 decoder: &mut fidl::encoding::Decoder<'_, D>,
2694 offset: usize,
2695 _depth: fidl::encoding::Depth,
2696 ) -> fidl::Result<()> {
2697 decoder.debug_check_bounds::<Self>(offset);
2698 fidl::decode!(
2700 fidl::encoding::UnboundedVector<Identity>,
2701 D,
2702 &mut self.identities,
2703 decoder,
2704 offset + 0,
2705 _depth
2706 )?;
2707 Ok(())
2708 }
2709 }
2710
2711 impl fidl::encoding::ValueTypeMarker for ConfigurationUpdateRequest {
2712 type Borrowed<'a> = &'a Self;
2713 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2714 value
2715 }
2716 }
2717
2718 unsafe impl fidl::encoding::TypeMarker for ConfigurationUpdateRequest {
2719 type Owned = Self;
2720
2721 #[inline(always)]
2722 fn inline_align(_context: fidl::encoding::Context) -> usize {
2723 8
2724 }
2725
2726 #[inline(always)]
2727 fn inline_size(_context: fidl::encoding::Context) -> usize {
2728 16
2729 }
2730 }
2731
2732 unsafe impl<D: fidl::encoding::ResourceDialect>
2733 fidl::encoding::Encode<ConfigurationUpdateRequest, D> for &ConfigurationUpdateRequest
2734 {
2735 #[inline]
2736 unsafe fn encode(
2737 self,
2738 encoder: &mut fidl::encoding::Encoder<'_, D>,
2739 offset: usize,
2740 _depth: fidl::encoding::Depth,
2741 ) -> fidl::Result<()> {
2742 encoder.debug_check_bounds::<ConfigurationUpdateRequest>(offset);
2743 fidl::encoding::Encode::<ConfigurationUpdateRequest, D>::encode(
2745 (<Settings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),),
2746 encoder,
2747 offset,
2748 _depth,
2749 )
2750 }
2751 }
2752 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Settings, D>>
2753 fidl::encoding::Encode<ConfigurationUpdateRequest, D> for (T0,)
2754 {
2755 #[inline]
2756 unsafe fn encode(
2757 self,
2758 encoder: &mut fidl::encoding::Encoder<'_, D>,
2759 offset: usize,
2760 depth: fidl::encoding::Depth,
2761 ) -> fidl::Result<()> {
2762 encoder.debug_check_bounds::<ConfigurationUpdateRequest>(offset);
2763 self.0.encode(encoder, offset + 0, depth)?;
2767 Ok(())
2768 }
2769 }
2770
2771 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2772 for ConfigurationUpdateRequest
2773 {
2774 #[inline(always)]
2775 fn new_empty() -> Self {
2776 Self { settings: fidl::new_empty!(Settings, D) }
2777 }
2778
2779 #[inline]
2780 unsafe fn decode(
2781 &mut self,
2782 decoder: &mut fidl::encoding::Decoder<'_, D>,
2783 offset: usize,
2784 _depth: fidl::encoding::Depth,
2785 ) -> fidl::Result<()> {
2786 decoder.debug_check_bounds::<Self>(offset);
2787 fidl::decode!(Settings, D, &mut self.settings, decoder, offset + 0, _depth)?;
2789 Ok(())
2790 }
2791 }
2792
2793 impl fidl::encoding::ValueTypeMarker for ConfigurationUpdateResponse {
2794 type Borrowed<'a> = &'a Self;
2795 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2796 value
2797 }
2798 }
2799
2800 unsafe impl fidl::encoding::TypeMarker for ConfigurationUpdateResponse {
2801 type Owned = Self;
2802
2803 #[inline(always)]
2804 fn inline_align(_context: fidl::encoding::Context) -> usize {
2805 8
2806 }
2807
2808 #[inline(always)]
2809 fn inline_size(_context: fidl::encoding::Context) -> usize {
2810 16
2811 }
2812 }
2813
2814 unsafe impl<D: fidl::encoding::ResourceDialect>
2815 fidl::encoding::Encode<ConfigurationUpdateResponse, D> for &ConfigurationUpdateResponse
2816 {
2817 #[inline]
2818 unsafe fn encode(
2819 self,
2820 encoder: &mut fidl::encoding::Encoder<'_, D>,
2821 offset: usize,
2822 _depth: fidl::encoding::Depth,
2823 ) -> fidl::Result<()> {
2824 encoder.debug_check_bounds::<ConfigurationUpdateResponse>(offset);
2825 fidl::encoding::Encode::<ConfigurationUpdateResponse, D>::encode(
2827 (<Settings as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
2828 encoder,
2829 offset,
2830 _depth,
2831 )
2832 }
2833 }
2834 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Settings, D>>
2835 fidl::encoding::Encode<ConfigurationUpdateResponse, D> for (T0,)
2836 {
2837 #[inline]
2838 unsafe fn encode(
2839 self,
2840 encoder: &mut fidl::encoding::Encoder<'_, D>,
2841 offset: usize,
2842 depth: fidl::encoding::Depth,
2843 ) -> fidl::Result<()> {
2844 encoder.debug_check_bounds::<ConfigurationUpdateResponse>(offset);
2845 self.0.encode(encoder, offset + 0, depth)?;
2849 Ok(())
2850 }
2851 }
2852
2853 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2854 for ConfigurationUpdateResponse
2855 {
2856 #[inline(always)]
2857 fn new_empty() -> Self {
2858 Self { result: fidl::new_empty!(Settings, D) }
2859 }
2860
2861 #[inline]
2862 unsafe fn decode(
2863 &mut self,
2864 decoder: &mut fidl::encoding::Decoder<'_, D>,
2865 offset: usize,
2866 _depth: fidl::encoding::Depth,
2867 ) -> fidl::Result<()> {
2868 decoder.debug_check_bounds::<Self>(offset);
2869 fidl::decode!(Settings, D, &mut self.result, decoder, offset + 0, _depth)?;
2871 Ok(())
2872 }
2873 }
2874
2875 impl fidl::encoding::ValueTypeMarker for Consent {
2876 type Borrowed<'a> = &'a Self;
2877 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2878 value
2879 }
2880 }
2881
2882 unsafe impl fidl::encoding::TypeMarker for Consent {
2883 type Owned = Self;
2884
2885 #[inline(always)]
2886 fn inline_align(_context: fidl::encoding::Context) -> usize {
2887 1
2888 }
2889
2890 #[inline(always)]
2891 fn inline_size(_context: fidl::encoding::Context) -> usize {
2892 1
2893 }
2894 }
2895
2896 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Consent, D> for &Consent {
2897 #[inline]
2898 unsafe fn encode(
2899 self,
2900 encoder: &mut fidl::encoding::Encoder<'_, D>,
2901 offset: usize,
2902 _depth: fidl::encoding::Depth,
2903 ) -> fidl::Result<()> {
2904 encoder.debug_check_bounds::<Consent>(offset);
2905 encoder.write_num(0u8, offset);
2906 Ok(())
2907 }
2908 }
2909
2910 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Consent {
2911 #[inline(always)]
2912 fn new_empty() -> Self {
2913 Self
2914 }
2915
2916 #[inline]
2917 unsafe fn decode(
2918 &mut self,
2919 decoder: &mut fidl::encoding::Decoder<'_, D>,
2920 offset: usize,
2921 _depth: fidl::encoding::Depth,
2922 ) -> fidl::Result<()> {
2923 decoder.debug_check_bounds::<Self>(offset);
2924 match decoder.read_num::<u8>(offset) {
2925 0 => Ok(()),
2926 _ => Err(fidl::Error::Invalid),
2927 }
2928 }
2929 }
2930
2931 impl fidl::encoding::ValueTypeMarker for HostWatcherSetActiveRequest {
2932 type Borrowed<'a> = &'a Self;
2933 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2934 value
2935 }
2936 }
2937
2938 unsafe impl fidl::encoding::TypeMarker for HostWatcherSetActiveRequest {
2939 type Owned = Self;
2940
2941 #[inline(always)]
2942 fn inline_align(_context: fidl::encoding::Context) -> usize {
2943 8
2944 }
2945
2946 #[inline(always)]
2947 fn inline_size(_context: fidl::encoding::Context) -> usize {
2948 8
2949 }
2950 }
2951
2952 unsafe impl<D: fidl::encoding::ResourceDialect>
2953 fidl::encoding::Encode<HostWatcherSetActiveRequest, D> for &HostWatcherSetActiveRequest
2954 {
2955 #[inline]
2956 unsafe fn encode(
2957 self,
2958 encoder: &mut fidl::encoding::Encoder<'_, D>,
2959 offset: usize,
2960 _depth: fidl::encoding::Depth,
2961 ) -> fidl::Result<()> {
2962 encoder.debug_check_bounds::<HostWatcherSetActiveRequest>(offset);
2963 fidl::encoding::Encode::<HostWatcherSetActiveRequest, D>::encode(
2965 (
2966 <fidl_fuchsia_bluetooth__common::HostId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
2967 ),
2968 encoder, offset, _depth
2969 )
2970 }
2971 }
2972 unsafe impl<
2973 D: fidl::encoding::ResourceDialect,
2974 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::HostId, D>,
2975 > fidl::encoding::Encode<HostWatcherSetActiveRequest, D> for (T0,)
2976 {
2977 #[inline]
2978 unsafe fn encode(
2979 self,
2980 encoder: &mut fidl::encoding::Encoder<'_, D>,
2981 offset: usize,
2982 depth: fidl::encoding::Depth,
2983 ) -> fidl::Result<()> {
2984 encoder.debug_check_bounds::<HostWatcherSetActiveRequest>(offset);
2985 self.0.encode(encoder, offset + 0, depth)?;
2989 Ok(())
2990 }
2991 }
2992
2993 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2994 for HostWatcherSetActiveRequest
2995 {
2996 #[inline(always)]
2997 fn new_empty() -> Self {
2998 Self { id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::HostId, D) }
2999 }
3000
3001 #[inline]
3002 unsafe fn decode(
3003 &mut self,
3004 decoder: &mut fidl::encoding::Decoder<'_, D>,
3005 offset: usize,
3006 _depth: fidl::encoding::Depth,
3007 ) -> fidl::Result<()> {
3008 decoder.debug_check_bounds::<Self>(offset);
3009 fidl::decode!(
3011 fidl_fuchsia_bluetooth__common::HostId,
3012 D,
3013 &mut self.id,
3014 decoder,
3015 offset + 0,
3016 _depth
3017 )?;
3018 Ok(())
3019 }
3020 }
3021
3022 impl fidl::encoding::ValueTypeMarker for HostWatcherWatchResponse {
3023 type Borrowed<'a> = &'a Self;
3024 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3025 value
3026 }
3027 }
3028
3029 unsafe impl fidl::encoding::TypeMarker for HostWatcherWatchResponse {
3030 type Owned = Self;
3031
3032 #[inline(always)]
3033 fn inline_align(_context: fidl::encoding::Context) -> usize {
3034 8
3035 }
3036
3037 #[inline(always)]
3038 fn inline_size(_context: fidl::encoding::Context) -> usize {
3039 16
3040 }
3041 }
3042
3043 unsafe impl<D: fidl::encoding::ResourceDialect>
3044 fidl::encoding::Encode<HostWatcherWatchResponse, D> for &HostWatcherWatchResponse
3045 {
3046 #[inline]
3047 unsafe fn encode(
3048 self,
3049 encoder: &mut fidl::encoding::Encoder<'_, D>,
3050 offset: usize,
3051 _depth: fidl::encoding::Depth,
3052 ) -> fidl::Result<()> {
3053 encoder.debug_check_bounds::<HostWatcherWatchResponse>(offset);
3054 fidl::encoding::Encode::<HostWatcherWatchResponse, D>::encode(
3056 (
3057 <fidl::encoding::UnboundedVector<HostInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.hosts),
3058 ),
3059 encoder, offset, _depth
3060 )
3061 }
3062 }
3063 unsafe impl<
3064 D: fidl::encoding::ResourceDialect,
3065 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<HostInfo>, D>,
3066 > fidl::encoding::Encode<HostWatcherWatchResponse, D> for (T0,)
3067 {
3068 #[inline]
3069 unsafe fn encode(
3070 self,
3071 encoder: &mut fidl::encoding::Encoder<'_, D>,
3072 offset: usize,
3073 depth: fidl::encoding::Depth,
3074 ) -> fidl::Result<()> {
3075 encoder.debug_check_bounds::<HostWatcherWatchResponse>(offset);
3076 self.0.encode(encoder, offset + 0, depth)?;
3080 Ok(())
3081 }
3082 }
3083
3084 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3085 for HostWatcherWatchResponse
3086 {
3087 #[inline(always)]
3088 fn new_empty() -> Self {
3089 Self { hosts: fidl::new_empty!(fidl::encoding::UnboundedVector<HostInfo>, D) }
3090 }
3091
3092 #[inline]
3093 unsafe fn decode(
3094 &mut self,
3095 decoder: &mut fidl::encoding::Decoder<'_, D>,
3096 offset: usize,
3097 _depth: fidl::encoding::Depth,
3098 ) -> fidl::Result<()> {
3099 decoder.debug_check_bounds::<Self>(offset);
3100 fidl::decode!(
3102 fidl::encoding::UnboundedVector<HostInfo>,
3103 D,
3104 &mut self.hosts,
3105 decoder,
3106 offset + 0,
3107 _depth
3108 )?;
3109 Ok(())
3110 }
3111 }
3112
3113 impl fidl::encoding::ValueTypeMarker for Key {
3114 type Borrowed<'a> = &'a Self;
3115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3116 value
3117 }
3118 }
3119
3120 unsafe impl fidl::encoding::TypeMarker for Key {
3121 type Owned = Self;
3122
3123 #[inline(always)]
3124 fn inline_align(_context: fidl::encoding::Context) -> usize {
3125 1
3126 }
3127
3128 #[inline(always)]
3129 fn inline_size(_context: fidl::encoding::Context) -> usize {
3130 16
3131 }
3132 #[inline(always)]
3133 fn encode_is_copy() -> bool {
3134 true
3135 }
3136
3137 #[inline(always)]
3138 fn decode_is_copy() -> bool {
3139 true
3140 }
3141 }
3142
3143 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Key, D> for &Key {
3144 #[inline]
3145 unsafe fn encode(
3146 self,
3147 encoder: &mut fidl::encoding::Encoder<'_, D>,
3148 offset: usize,
3149 _depth: fidl::encoding::Depth,
3150 ) -> fidl::Result<()> {
3151 encoder.debug_check_bounds::<Key>(offset);
3152 unsafe {
3153 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3155 (buf_ptr as *mut Key).write_unaligned((self as *const Key).read());
3156 }
3159 Ok(())
3160 }
3161 }
3162 unsafe impl<
3163 D: fidl::encoding::ResourceDialect,
3164 T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 16>, D>,
3165 > fidl::encoding::Encode<Key, D> for (T0,)
3166 {
3167 #[inline]
3168 unsafe fn encode(
3169 self,
3170 encoder: &mut fidl::encoding::Encoder<'_, D>,
3171 offset: usize,
3172 depth: fidl::encoding::Depth,
3173 ) -> fidl::Result<()> {
3174 encoder.debug_check_bounds::<Key>(offset);
3175 self.0.encode(encoder, offset + 0, depth)?;
3179 Ok(())
3180 }
3181 }
3182
3183 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Key {
3184 #[inline(always)]
3185 fn new_empty() -> Self {
3186 Self { value: fidl::new_empty!(fidl::encoding::Array<u8, 16>, D) }
3187 }
3188
3189 #[inline]
3190 unsafe fn decode(
3191 &mut self,
3192 decoder: &mut fidl::encoding::Decoder<'_, D>,
3193 offset: usize,
3194 _depth: fidl::encoding::Depth,
3195 ) -> fidl::Result<()> {
3196 decoder.debug_check_bounds::<Self>(offset);
3197 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3198 unsafe {
3201 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
3202 }
3203 Ok(())
3204 }
3205 }
3206
3207 impl fidl::encoding::ValueTypeMarker for LeConnectionParameters {
3208 type Borrowed<'a> = &'a Self;
3209 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3210 value
3211 }
3212 }
3213
3214 unsafe impl fidl::encoding::TypeMarker for LeConnectionParameters {
3215 type Owned = Self;
3216
3217 #[inline(always)]
3218 fn inline_align(_context: fidl::encoding::Context) -> usize {
3219 2
3220 }
3221
3222 #[inline(always)]
3223 fn inline_size(_context: fidl::encoding::Context) -> usize {
3224 6
3225 }
3226 #[inline(always)]
3227 fn encode_is_copy() -> bool {
3228 true
3229 }
3230
3231 #[inline(always)]
3232 fn decode_is_copy() -> bool {
3233 true
3234 }
3235 }
3236
3237 unsafe impl<D: fidl::encoding::ResourceDialect>
3238 fidl::encoding::Encode<LeConnectionParameters, D> for &LeConnectionParameters
3239 {
3240 #[inline]
3241 unsafe fn encode(
3242 self,
3243 encoder: &mut fidl::encoding::Encoder<'_, D>,
3244 offset: usize,
3245 _depth: fidl::encoding::Depth,
3246 ) -> fidl::Result<()> {
3247 encoder.debug_check_bounds::<LeConnectionParameters>(offset);
3248 unsafe {
3249 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3251 (buf_ptr as *mut LeConnectionParameters)
3252 .write_unaligned((self as *const LeConnectionParameters).read());
3253 }
3256 Ok(())
3257 }
3258 }
3259 unsafe impl<
3260 D: fidl::encoding::ResourceDialect,
3261 T0: fidl::encoding::Encode<u16, D>,
3262 T1: fidl::encoding::Encode<u16, D>,
3263 T2: fidl::encoding::Encode<u16, D>,
3264 > fidl::encoding::Encode<LeConnectionParameters, D> for (T0, T1, T2)
3265 {
3266 #[inline]
3267 unsafe fn encode(
3268 self,
3269 encoder: &mut fidl::encoding::Encoder<'_, D>,
3270 offset: usize,
3271 depth: fidl::encoding::Depth,
3272 ) -> fidl::Result<()> {
3273 encoder.debug_check_bounds::<LeConnectionParameters>(offset);
3274 self.0.encode(encoder, offset + 0, depth)?;
3278 self.1.encode(encoder, offset + 2, depth)?;
3279 self.2.encode(encoder, offset + 4, depth)?;
3280 Ok(())
3281 }
3282 }
3283
3284 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3285 for LeConnectionParameters
3286 {
3287 #[inline(always)]
3288 fn new_empty() -> Self {
3289 Self {
3290 connection_interval: fidl::new_empty!(u16, D),
3291 connection_latency: fidl::new_empty!(u16, D),
3292 supervision_timeout: fidl::new_empty!(u16, D),
3293 }
3294 }
3295
3296 #[inline]
3297 unsafe fn decode(
3298 &mut self,
3299 decoder: &mut fidl::encoding::Decoder<'_, D>,
3300 offset: usize,
3301 _depth: fidl::encoding::Depth,
3302 ) -> fidl::Result<()> {
3303 decoder.debug_check_bounds::<Self>(offset);
3304 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3305 unsafe {
3308 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
3309 }
3310 Ok(())
3311 }
3312 }
3313
3314 impl fidl::encoding::ValueTypeMarker for Ltk {
3315 type Borrowed<'a> = &'a Self;
3316 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3317 value
3318 }
3319 }
3320
3321 unsafe impl fidl::encoding::TypeMarker for Ltk {
3322 type Owned = Self;
3323
3324 #[inline(always)]
3325 fn inline_align(_context: fidl::encoding::Context) -> usize {
3326 8
3327 }
3328
3329 #[inline(always)]
3330 fn inline_size(_context: fidl::encoding::Context) -> usize {
3331 32
3332 }
3333 }
3334
3335 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ltk, D> for &Ltk {
3336 #[inline]
3337 unsafe fn encode(
3338 self,
3339 encoder: &mut fidl::encoding::Encoder<'_, D>,
3340 offset: usize,
3341 _depth: fidl::encoding::Depth,
3342 ) -> fidl::Result<()> {
3343 encoder.debug_check_bounds::<Ltk>(offset);
3344 fidl::encoding::Encode::<Ltk, D>::encode(
3346 (
3347 <PeerKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
3348 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.ediv),
3349 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.rand),
3350 ),
3351 encoder,
3352 offset,
3353 _depth,
3354 )
3355 }
3356 }
3357 unsafe impl<
3358 D: fidl::encoding::ResourceDialect,
3359 T0: fidl::encoding::Encode<PeerKey, D>,
3360 T1: fidl::encoding::Encode<u16, D>,
3361 T2: fidl::encoding::Encode<u64, D>,
3362 > fidl::encoding::Encode<Ltk, D> for (T0, T1, T2)
3363 {
3364 #[inline]
3365 unsafe fn encode(
3366 self,
3367 encoder: &mut fidl::encoding::Encoder<'_, D>,
3368 offset: usize,
3369 depth: fidl::encoding::Depth,
3370 ) -> fidl::Result<()> {
3371 encoder.debug_check_bounds::<Ltk>(offset);
3372 unsafe {
3375 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
3376 (ptr as *mut u64).write_unaligned(0);
3377 }
3378 self.0.encode(encoder, offset + 0, depth)?;
3380 self.1.encode(encoder, offset + 20, depth)?;
3381 self.2.encode(encoder, offset + 24, depth)?;
3382 Ok(())
3383 }
3384 }
3385
3386 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ltk {
3387 #[inline(always)]
3388 fn new_empty() -> Self {
3389 Self {
3390 key: fidl::new_empty!(PeerKey, D),
3391 ediv: fidl::new_empty!(u16, D),
3392 rand: fidl::new_empty!(u64, D),
3393 }
3394 }
3395
3396 #[inline]
3397 unsafe fn decode(
3398 &mut self,
3399 decoder: &mut fidl::encoding::Decoder<'_, D>,
3400 offset: usize,
3401 _depth: fidl::encoding::Depth,
3402 ) -> fidl::Result<()> {
3403 decoder.debug_check_bounds::<Self>(offset);
3404 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
3406 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3407 let mask = 0xffff0000ff000000u64;
3408 let maskedval = padval & mask;
3409 if maskedval != 0 {
3410 return Err(fidl::Error::NonZeroPadding {
3411 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
3412 });
3413 }
3414 fidl::decode!(PeerKey, D, &mut self.key, decoder, offset + 0, _depth)?;
3415 fidl::decode!(u16, D, &mut self.ediv, decoder, offset + 20, _depth)?;
3416 fidl::decode!(u64, D, &mut self.rand, decoder, offset + 24, _depth)?;
3417 Ok(())
3418 }
3419 }
3420
3421 impl fidl::encoding::ValueTypeMarker for PairingDelegate2RequestCompleteRequest {
3422 type Borrowed<'a> = &'a Self;
3423 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3424 value
3425 }
3426 }
3427
3428 unsafe impl fidl::encoding::TypeMarker for PairingDelegate2RequestCompleteRequest {
3429 type Owned = Self;
3430
3431 #[inline(always)]
3432 fn inline_align(_context: fidl::encoding::Context) -> usize {
3433 8
3434 }
3435
3436 #[inline(always)]
3437 fn inline_size(_context: fidl::encoding::Context) -> usize {
3438 16
3439 }
3440 }
3441
3442 unsafe impl<D: fidl::encoding::ResourceDialect>
3443 fidl::encoding::Encode<PairingDelegate2RequestCompleteRequest, D>
3444 for &PairingDelegate2RequestCompleteRequest
3445 {
3446 #[inline]
3447 unsafe fn encode(
3448 self,
3449 encoder: &mut fidl::encoding::Encoder<'_, D>,
3450 offset: usize,
3451 _depth: fidl::encoding::Depth,
3452 ) -> fidl::Result<()> {
3453 encoder.debug_check_bounds::<PairingDelegate2RequestCompleteRequest>(offset);
3454 fidl::encoding::Encode::<PairingDelegate2RequestCompleteRequest, D>::encode(
3456 (
3457 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3458 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.success),
3459 ),
3460 encoder, offset, _depth
3461 )
3462 }
3463 }
3464 unsafe impl<
3465 D: fidl::encoding::ResourceDialect,
3466 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
3467 T1: fidl::encoding::Encode<bool, D>,
3468 > fidl::encoding::Encode<PairingDelegate2RequestCompleteRequest, D> for (T0, T1)
3469 {
3470 #[inline]
3471 unsafe fn encode(
3472 self,
3473 encoder: &mut fidl::encoding::Encoder<'_, D>,
3474 offset: usize,
3475 depth: fidl::encoding::Depth,
3476 ) -> fidl::Result<()> {
3477 encoder.debug_check_bounds::<PairingDelegate2RequestCompleteRequest>(offset);
3478 unsafe {
3481 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
3482 (ptr as *mut u64).write_unaligned(0);
3483 }
3484 self.0.encode(encoder, offset + 0, depth)?;
3486 self.1.encode(encoder, offset + 8, depth)?;
3487 Ok(())
3488 }
3489 }
3490
3491 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3492 for PairingDelegate2RequestCompleteRequest
3493 {
3494 #[inline(always)]
3495 fn new_empty() -> Self {
3496 Self {
3497 id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
3498 success: fidl::new_empty!(bool, D),
3499 }
3500 }
3501
3502 #[inline]
3503 unsafe fn decode(
3504 &mut self,
3505 decoder: &mut fidl::encoding::Decoder<'_, D>,
3506 offset: usize,
3507 _depth: fidl::encoding::Depth,
3508 ) -> fidl::Result<()> {
3509 decoder.debug_check_bounds::<Self>(offset);
3510 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
3512 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3513 let mask = 0xffffffffffffff00u64;
3514 let maskedval = padval & mask;
3515 if maskedval != 0 {
3516 return Err(fidl::Error::NonZeroPadding {
3517 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
3518 });
3519 }
3520 fidl::decode!(
3521 fidl_fuchsia_bluetooth__common::PeerId,
3522 D,
3523 &mut self.id,
3524 decoder,
3525 offset + 0,
3526 _depth
3527 )?;
3528 fidl::decode!(bool, D, &mut self.success, decoder, offset + 8, _depth)?;
3529 Ok(())
3530 }
3531 }
3532
3533 impl fidl::encoding::ValueTypeMarker for PairingDelegateOnLocalKeypressRequest {
3534 type Borrowed<'a> = &'a Self;
3535 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3536 value
3537 }
3538 }
3539
3540 unsafe impl fidl::encoding::TypeMarker for PairingDelegateOnLocalKeypressRequest {
3541 type Owned = Self;
3542
3543 #[inline(always)]
3544 fn inline_align(_context: fidl::encoding::Context) -> usize {
3545 8
3546 }
3547
3548 #[inline(always)]
3549 fn inline_size(_context: fidl::encoding::Context) -> usize {
3550 16
3551 }
3552 }
3553
3554 unsafe impl<D: fidl::encoding::ResourceDialect>
3555 fidl::encoding::Encode<PairingDelegateOnLocalKeypressRequest, D>
3556 for &PairingDelegateOnLocalKeypressRequest
3557 {
3558 #[inline]
3559 unsafe fn encode(
3560 self,
3561 encoder: &mut fidl::encoding::Encoder<'_, D>,
3562 offset: usize,
3563 _depth: fidl::encoding::Depth,
3564 ) -> fidl::Result<()> {
3565 encoder.debug_check_bounds::<PairingDelegateOnLocalKeypressRequest>(offset);
3566 fidl::encoding::Encode::<PairingDelegateOnLocalKeypressRequest, D>::encode(
3568 (
3569 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3570 <PairingKeypress as fidl::encoding::ValueTypeMarker>::borrow(&self.keypress),
3571 ),
3572 encoder, offset, _depth
3573 )
3574 }
3575 }
3576 unsafe impl<
3577 D: fidl::encoding::ResourceDialect,
3578 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
3579 T1: fidl::encoding::Encode<PairingKeypress, D>,
3580 > fidl::encoding::Encode<PairingDelegateOnLocalKeypressRequest, D> for (T0, T1)
3581 {
3582 #[inline]
3583 unsafe fn encode(
3584 self,
3585 encoder: &mut fidl::encoding::Encoder<'_, D>,
3586 offset: usize,
3587 depth: fidl::encoding::Depth,
3588 ) -> fidl::Result<()> {
3589 encoder.debug_check_bounds::<PairingDelegateOnLocalKeypressRequest>(offset);
3590 unsafe {
3593 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
3594 (ptr as *mut u64).write_unaligned(0);
3595 }
3596 self.0.encode(encoder, offset + 0, depth)?;
3598 self.1.encode(encoder, offset + 8, depth)?;
3599 Ok(())
3600 }
3601 }
3602
3603 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3604 for PairingDelegateOnLocalKeypressRequest
3605 {
3606 #[inline(always)]
3607 fn new_empty() -> Self {
3608 Self {
3609 id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
3610 keypress: fidl::new_empty!(PairingKeypress, D),
3611 }
3612 }
3613
3614 #[inline]
3615 unsafe fn decode(
3616 &mut self,
3617 decoder: &mut fidl::encoding::Decoder<'_, D>,
3618 offset: usize,
3619 _depth: fidl::encoding::Depth,
3620 ) -> fidl::Result<()> {
3621 decoder.debug_check_bounds::<Self>(offset);
3622 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
3624 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3625 let mask = 0xffffffff00000000u64;
3626 let maskedval = padval & mask;
3627 if maskedval != 0 {
3628 return Err(fidl::Error::NonZeroPadding {
3629 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
3630 });
3631 }
3632 fidl::decode!(
3633 fidl_fuchsia_bluetooth__common::PeerId,
3634 D,
3635 &mut self.id,
3636 decoder,
3637 offset + 0,
3638 _depth
3639 )?;
3640 fidl::decode!(PairingKeypress, D, &mut self.keypress, decoder, offset + 8, _depth)?;
3641 Ok(())
3642 }
3643 }
3644
3645 impl fidl::encoding::ValueTypeMarker for PairingDelegateOnPairingCompleteRequest {
3646 type Borrowed<'a> = &'a Self;
3647 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3648 value
3649 }
3650 }
3651
3652 unsafe impl fidl::encoding::TypeMarker for PairingDelegateOnPairingCompleteRequest {
3653 type Owned = Self;
3654
3655 #[inline(always)]
3656 fn inline_align(_context: fidl::encoding::Context) -> usize {
3657 8
3658 }
3659
3660 #[inline(always)]
3661 fn inline_size(_context: fidl::encoding::Context) -> usize {
3662 16
3663 }
3664 }
3665
3666 unsafe impl<D: fidl::encoding::ResourceDialect>
3667 fidl::encoding::Encode<PairingDelegateOnPairingCompleteRequest, D>
3668 for &PairingDelegateOnPairingCompleteRequest
3669 {
3670 #[inline]
3671 unsafe fn encode(
3672 self,
3673 encoder: &mut fidl::encoding::Encoder<'_, D>,
3674 offset: usize,
3675 _depth: fidl::encoding::Depth,
3676 ) -> fidl::Result<()> {
3677 encoder.debug_check_bounds::<PairingDelegateOnPairingCompleteRequest>(offset);
3678 fidl::encoding::Encode::<PairingDelegateOnPairingCompleteRequest, D>::encode(
3680 (
3681 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3682 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.success),
3683 ),
3684 encoder, offset, _depth
3685 )
3686 }
3687 }
3688 unsafe impl<
3689 D: fidl::encoding::ResourceDialect,
3690 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
3691 T1: fidl::encoding::Encode<bool, D>,
3692 > fidl::encoding::Encode<PairingDelegateOnPairingCompleteRequest, D> for (T0, T1)
3693 {
3694 #[inline]
3695 unsafe fn encode(
3696 self,
3697 encoder: &mut fidl::encoding::Encoder<'_, D>,
3698 offset: usize,
3699 depth: fidl::encoding::Depth,
3700 ) -> fidl::Result<()> {
3701 encoder.debug_check_bounds::<PairingDelegateOnPairingCompleteRequest>(offset);
3702 unsafe {
3705 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
3706 (ptr as *mut u64).write_unaligned(0);
3707 }
3708 self.0.encode(encoder, offset + 0, depth)?;
3710 self.1.encode(encoder, offset + 8, depth)?;
3711 Ok(())
3712 }
3713 }
3714
3715 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3716 for PairingDelegateOnPairingCompleteRequest
3717 {
3718 #[inline(always)]
3719 fn new_empty() -> Self {
3720 Self {
3721 id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
3722 success: fidl::new_empty!(bool, D),
3723 }
3724 }
3725
3726 #[inline]
3727 unsafe fn decode(
3728 &mut self,
3729 decoder: &mut fidl::encoding::Decoder<'_, D>,
3730 offset: usize,
3731 _depth: fidl::encoding::Depth,
3732 ) -> fidl::Result<()> {
3733 decoder.debug_check_bounds::<Self>(offset);
3734 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
3736 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3737 let mask = 0xffffffffffffff00u64;
3738 let maskedval = padval & mask;
3739 if maskedval != 0 {
3740 return Err(fidl::Error::NonZeroPadding {
3741 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
3742 });
3743 }
3744 fidl::decode!(
3745 fidl_fuchsia_bluetooth__common::PeerId,
3746 D,
3747 &mut self.id,
3748 decoder,
3749 offset + 0,
3750 _depth
3751 )?;
3752 fidl::decode!(bool, D, &mut self.success, decoder, offset + 8, _depth)?;
3753 Ok(())
3754 }
3755 }
3756
3757 impl fidl::encoding::ValueTypeMarker for PairingDelegateOnPairingRequestRequest {
3758 type Borrowed<'a> = &'a Self;
3759 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3760 value
3761 }
3762 }
3763
3764 unsafe impl fidl::encoding::TypeMarker for PairingDelegateOnPairingRequestRequest {
3765 type Owned = Self;
3766
3767 #[inline(always)]
3768 fn inline_align(_context: fidl::encoding::Context) -> usize {
3769 8
3770 }
3771
3772 #[inline(always)]
3773 fn inline_size(_context: fidl::encoding::Context) -> usize {
3774 24
3775 }
3776 }
3777
3778 unsafe impl<D: fidl::encoding::ResourceDialect>
3779 fidl::encoding::Encode<PairingDelegateOnPairingRequestRequest, D>
3780 for &PairingDelegateOnPairingRequestRequest
3781 {
3782 #[inline]
3783 unsafe fn encode(
3784 self,
3785 encoder: &mut fidl::encoding::Encoder<'_, D>,
3786 offset: usize,
3787 _depth: fidl::encoding::Depth,
3788 ) -> fidl::Result<()> {
3789 encoder.debug_check_bounds::<PairingDelegateOnPairingRequestRequest>(offset);
3790 fidl::encoding::Encode::<PairingDelegateOnPairingRequestRequest, D>::encode(
3792 (
3793 <Peer as fidl::encoding::ValueTypeMarker>::borrow(&self.peer),
3794 <PairingMethod as fidl::encoding::ValueTypeMarker>::borrow(&self.method),
3795 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.displayed_passkey),
3796 ),
3797 encoder,
3798 offset,
3799 _depth,
3800 )
3801 }
3802 }
3803 unsafe impl<
3804 D: fidl::encoding::ResourceDialect,
3805 T0: fidl::encoding::Encode<Peer, D>,
3806 T1: fidl::encoding::Encode<PairingMethod, D>,
3807 T2: fidl::encoding::Encode<u32, D>,
3808 > fidl::encoding::Encode<PairingDelegateOnPairingRequestRequest, D> for (T0, T1, T2)
3809 {
3810 #[inline]
3811 unsafe fn encode(
3812 self,
3813 encoder: &mut fidl::encoding::Encoder<'_, D>,
3814 offset: usize,
3815 depth: fidl::encoding::Depth,
3816 ) -> fidl::Result<()> {
3817 encoder.debug_check_bounds::<PairingDelegateOnPairingRequestRequest>(offset);
3818 self.0.encode(encoder, offset + 0, depth)?;
3822 self.1.encode(encoder, offset + 16, depth)?;
3823 self.2.encode(encoder, offset + 20, depth)?;
3824 Ok(())
3825 }
3826 }
3827
3828 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3829 for PairingDelegateOnPairingRequestRequest
3830 {
3831 #[inline(always)]
3832 fn new_empty() -> Self {
3833 Self {
3834 peer: fidl::new_empty!(Peer, D),
3835 method: fidl::new_empty!(PairingMethod, D),
3836 displayed_passkey: fidl::new_empty!(u32, D),
3837 }
3838 }
3839
3840 #[inline]
3841 unsafe fn decode(
3842 &mut self,
3843 decoder: &mut fidl::encoding::Decoder<'_, D>,
3844 offset: usize,
3845 _depth: fidl::encoding::Depth,
3846 ) -> fidl::Result<()> {
3847 decoder.debug_check_bounds::<Self>(offset);
3848 fidl::decode!(Peer, D, &mut self.peer, decoder, offset + 0, _depth)?;
3850 fidl::decode!(PairingMethod, D, &mut self.method, decoder, offset + 16, _depth)?;
3851 fidl::decode!(u32, D, &mut self.displayed_passkey, decoder, offset + 20, _depth)?;
3852 Ok(())
3853 }
3854 }
3855
3856 impl fidl::encoding::ValueTypeMarker for PairingDelegateOnPairingRequestResponse {
3857 type Borrowed<'a> = &'a Self;
3858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3859 value
3860 }
3861 }
3862
3863 unsafe impl fidl::encoding::TypeMarker for PairingDelegateOnPairingRequestResponse {
3864 type Owned = Self;
3865
3866 #[inline(always)]
3867 fn inline_align(_context: fidl::encoding::Context) -> usize {
3868 4
3869 }
3870
3871 #[inline(always)]
3872 fn inline_size(_context: fidl::encoding::Context) -> usize {
3873 8
3874 }
3875 }
3876
3877 unsafe impl<D: fidl::encoding::ResourceDialect>
3878 fidl::encoding::Encode<PairingDelegateOnPairingRequestResponse, D>
3879 for &PairingDelegateOnPairingRequestResponse
3880 {
3881 #[inline]
3882 unsafe fn encode(
3883 self,
3884 encoder: &mut fidl::encoding::Encoder<'_, D>,
3885 offset: usize,
3886 _depth: fidl::encoding::Depth,
3887 ) -> fidl::Result<()> {
3888 encoder.debug_check_bounds::<PairingDelegateOnPairingRequestResponse>(offset);
3889 fidl::encoding::Encode::<PairingDelegateOnPairingRequestResponse, D>::encode(
3891 (
3892 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.accept),
3893 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.entered_passkey),
3894 ),
3895 encoder,
3896 offset,
3897 _depth,
3898 )
3899 }
3900 }
3901 unsafe impl<
3902 D: fidl::encoding::ResourceDialect,
3903 T0: fidl::encoding::Encode<bool, D>,
3904 T1: fidl::encoding::Encode<u32, D>,
3905 > fidl::encoding::Encode<PairingDelegateOnPairingRequestResponse, D> for (T0, T1)
3906 {
3907 #[inline]
3908 unsafe fn encode(
3909 self,
3910 encoder: &mut fidl::encoding::Encoder<'_, D>,
3911 offset: usize,
3912 depth: fidl::encoding::Depth,
3913 ) -> fidl::Result<()> {
3914 encoder.debug_check_bounds::<PairingDelegateOnPairingRequestResponse>(offset);
3915 unsafe {
3918 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3919 (ptr as *mut u32).write_unaligned(0);
3920 }
3921 self.0.encode(encoder, offset + 0, depth)?;
3923 self.1.encode(encoder, offset + 4, depth)?;
3924 Ok(())
3925 }
3926 }
3927
3928 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3929 for PairingDelegateOnPairingRequestResponse
3930 {
3931 #[inline(always)]
3932 fn new_empty() -> Self {
3933 Self { accept: fidl::new_empty!(bool, D), entered_passkey: fidl::new_empty!(u32, D) }
3934 }
3935
3936 #[inline]
3937 unsafe fn decode(
3938 &mut self,
3939 decoder: &mut fidl::encoding::Decoder<'_, D>,
3940 offset: usize,
3941 _depth: fidl::encoding::Depth,
3942 ) -> fidl::Result<()> {
3943 decoder.debug_check_bounds::<Self>(offset);
3944 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3946 let padval = unsafe { (ptr as *const u32).read_unaligned() };
3947 let mask = 0xffffff00u32;
3948 let maskedval = padval & mask;
3949 if maskedval != 0 {
3950 return Err(fidl::Error::NonZeroPadding {
3951 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3952 });
3953 }
3954 fidl::decode!(bool, D, &mut self.accept, decoder, offset + 0, _depth)?;
3955 fidl::decode!(u32, D, &mut self.entered_passkey, decoder, offset + 4, _depth)?;
3956 Ok(())
3957 }
3958 }
3959
3960 impl fidl::encoding::ValueTypeMarker for PairingDelegateOnRemoteKeypressRequest {
3961 type Borrowed<'a> = &'a Self;
3962 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3963 value
3964 }
3965 }
3966
3967 unsafe impl fidl::encoding::TypeMarker for PairingDelegateOnRemoteKeypressRequest {
3968 type Owned = Self;
3969
3970 #[inline(always)]
3971 fn inline_align(_context: fidl::encoding::Context) -> usize {
3972 8
3973 }
3974
3975 #[inline(always)]
3976 fn inline_size(_context: fidl::encoding::Context) -> usize {
3977 16
3978 }
3979 }
3980
3981 unsafe impl<D: fidl::encoding::ResourceDialect>
3982 fidl::encoding::Encode<PairingDelegateOnRemoteKeypressRequest, D>
3983 for &PairingDelegateOnRemoteKeypressRequest
3984 {
3985 #[inline]
3986 unsafe fn encode(
3987 self,
3988 encoder: &mut fidl::encoding::Encoder<'_, D>,
3989 offset: usize,
3990 _depth: fidl::encoding::Depth,
3991 ) -> fidl::Result<()> {
3992 encoder.debug_check_bounds::<PairingDelegateOnRemoteKeypressRequest>(offset);
3993 fidl::encoding::Encode::<PairingDelegateOnRemoteKeypressRequest, D>::encode(
3995 (
3996 <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3997 <PairingKeypress as fidl::encoding::ValueTypeMarker>::borrow(&self.keypress),
3998 ),
3999 encoder, offset, _depth
4000 )
4001 }
4002 }
4003 unsafe impl<
4004 D: fidl::encoding::ResourceDialect,
4005 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::PeerId, D>,
4006 T1: fidl::encoding::Encode<PairingKeypress, D>,
4007 > fidl::encoding::Encode<PairingDelegateOnRemoteKeypressRequest, D> for (T0, T1)
4008 {
4009 #[inline]
4010 unsafe fn encode(
4011 self,
4012 encoder: &mut fidl::encoding::Encoder<'_, D>,
4013 offset: usize,
4014 depth: fidl::encoding::Depth,
4015 ) -> fidl::Result<()> {
4016 encoder.debug_check_bounds::<PairingDelegateOnRemoteKeypressRequest>(offset);
4017 unsafe {
4020 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
4021 (ptr as *mut u64).write_unaligned(0);
4022 }
4023 self.0.encode(encoder, offset + 0, depth)?;
4025 self.1.encode(encoder, offset + 8, depth)?;
4026 Ok(())
4027 }
4028 }
4029
4030 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4031 for PairingDelegateOnRemoteKeypressRequest
4032 {
4033 #[inline(always)]
4034 fn new_empty() -> Self {
4035 Self {
4036 id: fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D),
4037 keypress: fidl::new_empty!(PairingKeypress, D),
4038 }
4039 }
4040
4041 #[inline]
4042 unsafe fn decode(
4043 &mut self,
4044 decoder: &mut fidl::encoding::Decoder<'_, D>,
4045 offset: usize,
4046 _depth: fidl::encoding::Depth,
4047 ) -> fidl::Result<()> {
4048 decoder.debug_check_bounds::<Self>(offset);
4049 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
4051 let padval = unsafe { (ptr as *const u64).read_unaligned() };
4052 let mask = 0xffffffff00000000u64;
4053 let maskedval = padval & mask;
4054 if maskedval != 0 {
4055 return Err(fidl::Error::NonZeroPadding {
4056 padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
4057 });
4058 }
4059 fidl::decode!(
4060 fidl_fuchsia_bluetooth__common::PeerId,
4061 D,
4062 &mut self.id,
4063 decoder,
4064 offset + 0,
4065 _depth
4066 )?;
4067 fidl::decode!(PairingKeypress, D, &mut self.keypress, decoder, offset + 8, _depth)?;
4068 Ok(())
4069 }
4070 }
4071
4072 impl fidl::encoding::ValueTypeMarker for PairingRequestKeypressRequest {
4073 type Borrowed<'a> = &'a Self;
4074 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4075 value
4076 }
4077 }
4078
4079 unsafe impl fidl::encoding::TypeMarker for PairingRequestKeypressRequest {
4080 type Owned = Self;
4081
4082 #[inline(always)]
4083 fn inline_align(_context: fidl::encoding::Context) -> usize {
4084 4
4085 }
4086
4087 #[inline(always)]
4088 fn inline_size(_context: fidl::encoding::Context) -> usize {
4089 4
4090 }
4091 }
4092
4093 unsafe impl<D: fidl::encoding::ResourceDialect>
4094 fidl::encoding::Encode<PairingRequestKeypressRequest, D>
4095 for &PairingRequestKeypressRequest
4096 {
4097 #[inline]
4098 unsafe fn encode(
4099 self,
4100 encoder: &mut fidl::encoding::Encoder<'_, D>,
4101 offset: usize,
4102 _depth: fidl::encoding::Depth,
4103 ) -> fidl::Result<()> {
4104 encoder.debug_check_bounds::<PairingRequestKeypressRequest>(offset);
4105 fidl::encoding::Encode::<PairingRequestKeypressRequest, D>::encode(
4107 (<PairingKeypress as fidl::encoding::ValueTypeMarker>::borrow(&self.keypress),),
4108 encoder,
4109 offset,
4110 _depth,
4111 )
4112 }
4113 }
4114 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PairingKeypress, D>>
4115 fidl::encoding::Encode<PairingRequestKeypressRequest, D> for (T0,)
4116 {
4117 #[inline]
4118 unsafe fn encode(
4119 self,
4120 encoder: &mut fidl::encoding::Encoder<'_, D>,
4121 offset: usize,
4122 depth: fidl::encoding::Depth,
4123 ) -> fidl::Result<()> {
4124 encoder.debug_check_bounds::<PairingRequestKeypressRequest>(offset);
4125 self.0.encode(encoder, offset + 0, depth)?;
4129 Ok(())
4130 }
4131 }
4132
4133 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4134 for PairingRequestKeypressRequest
4135 {
4136 #[inline(always)]
4137 fn new_empty() -> Self {
4138 Self { keypress: fidl::new_empty!(PairingKeypress, D) }
4139 }
4140
4141 #[inline]
4142 unsafe fn decode(
4143 &mut self,
4144 decoder: &mut fidl::encoding::Decoder<'_, D>,
4145 offset: usize,
4146 _depth: fidl::encoding::Depth,
4147 ) -> fidl::Result<()> {
4148 decoder.debug_check_bounds::<Self>(offset);
4149 fidl::decode!(PairingKeypress, D, &mut self.keypress, decoder, offset + 0, _depth)?;
4151 Ok(())
4152 }
4153 }
4154
4155 impl fidl::encoding::ValueTypeMarker for PairingRequestOnCompleteRequest {
4156 type Borrowed<'a> = &'a Self;
4157 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4158 value
4159 }
4160 }
4161
4162 unsafe impl fidl::encoding::TypeMarker for PairingRequestOnCompleteRequest {
4163 type Owned = Self;
4164
4165 #[inline(always)]
4166 fn inline_align(_context: fidl::encoding::Context) -> usize {
4167 1
4168 }
4169
4170 #[inline(always)]
4171 fn inline_size(_context: fidl::encoding::Context) -> usize {
4172 1
4173 }
4174 }
4175
4176 unsafe impl<D: fidl::encoding::ResourceDialect>
4177 fidl::encoding::Encode<PairingRequestOnCompleteRequest, D>
4178 for &PairingRequestOnCompleteRequest
4179 {
4180 #[inline]
4181 unsafe fn encode(
4182 self,
4183 encoder: &mut fidl::encoding::Encoder<'_, D>,
4184 offset: usize,
4185 _depth: fidl::encoding::Depth,
4186 ) -> fidl::Result<()> {
4187 encoder.debug_check_bounds::<PairingRequestOnCompleteRequest>(offset);
4188 fidl::encoding::Encode::<PairingRequestOnCompleteRequest, D>::encode(
4190 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.success),),
4191 encoder,
4192 offset,
4193 _depth,
4194 )
4195 }
4196 }
4197 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
4198 fidl::encoding::Encode<PairingRequestOnCompleteRequest, D> for (T0,)
4199 {
4200 #[inline]
4201 unsafe fn encode(
4202 self,
4203 encoder: &mut fidl::encoding::Encoder<'_, D>,
4204 offset: usize,
4205 depth: fidl::encoding::Depth,
4206 ) -> fidl::Result<()> {
4207 encoder.debug_check_bounds::<PairingRequestOnCompleteRequest>(offset);
4208 self.0.encode(encoder, offset + 0, depth)?;
4212 Ok(())
4213 }
4214 }
4215
4216 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4217 for PairingRequestOnCompleteRequest
4218 {
4219 #[inline(always)]
4220 fn new_empty() -> Self {
4221 Self { success: fidl::new_empty!(bool, D) }
4222 }
4223
4224 #[inline]
4225 unsafe fn decode(
4226 &mut self,
4227 decoder: &mut fidl::encoding::Decoder<'_, D>,
4228 offset: usize,
4229 _depth: fidl::encoding::Depth,
4230 ) -> fidl::Result<()> {
4231 decoder.debug_check_bounds::<Self>(offset);
4232 fidl::decode!(bool, D, &mut self.success, decoder, offset + 0, _depth)?;
4234 Ok(())
4235 }
4236 }
4237
4238 impl fidl::encoding::ValueTypeMarker for PairingRequestOnKeypressRequest {
4239 type Borrowed<'a> = &'a Self;
4240 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4241 value
4242 }
4243 }
4244
4245 unsafe impl fidl::encoding::TypeMarker for PairingRequestOnKeypressRequest {
4246 type Owned = Self;
4247
4248 #[inline(always)]
4249 fn inline_align(_context: fidl::encoding::Context) -> usize {
4250 4
4251 }
4252
4253 #[inline(always)]
4254 fn inline_size(_context: fidl::encoding::Context) -> usize {
4255 4
4256 }
4257 }
4258
4259 unsafe impl<D: fidl::encoding::ResourceDialect>
4260 fidl::encoding::Encode<PairingRequestOnKeypressRequest, D>
4261 for &PairingRequestOnKeypressRequest
4262 {
4263 #[inline]
4264 unsafe fn encode(
4265 self,
4266 encoder: &mut fidl::encoding::Encoder<'_, D>,
4267 offset: usize,
4268 _depth: fidl::encoding::Depth,
4269 ) -> fidl::Result<()> {
4270 encoder.debug_check_bounds::<PairingRequestOnKeypressRequest>(offset);
4271 fidl::encoding::Encode::<PairingRequestOnKeypressRequest, D>::encode(
4273 (<PairingKeypress as fidl::encoding::ValueTypeMarker>::borrow(&self.keypress),),
4274 encoder,
4275 offset,
4276 _depth,
4277 )
4278 }
4279 }
4280 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PairingKeypress, D>>
4281 fidl::encoding::Encode<PairingRequestOnKeypressRequest, D> for (T0,)
4282 {
4283 #[inline]
4284 unsafe fn encode(
4285 self,
4286 encoder: &mut fidl::encoding::Encoder<'_, D>,
4287 offset: usize,
4288 depth: fidl::encoding::Depth,
4289 ) -> fidl::Result<()> {
4290 encoder.debug_check_bounds::<PairingRequestOnKeypressRequest>(offset);
4291 self.0.encode(encoder, offset + 0, depth)?;
4295 Ok(())
4296 }
4297 }
4298
4299 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4300 for PairingRequestOnKeypressRequest
4301 {
4302 #[inline(always)]
4303 fn new_empty() -> Self {
4304 Self { keypress: fidl::new_empty!(PairingKeypress, D) }
4305 }
4306
4307 #[inline]
4308 unsafe fn decode(
4309 &mut self,
4310 decoder: &mut fidl::encoding::Decoder<'_, D>,
4311 offset: usize,
4312 _depth: fidl::encoding::Depth,
4313 ) -> fidl::Result<()> {
4314 decoder.debug_check_bounds::<Self>(offset);
4315 fidl::decode!(PairingKeypress, D, &mut self.keypress, decoder, offset + 0, _depth)?;
4317 Ok(())
4318 }
4319 }
4320
4321 impl fidl::encoding::ValueTypeMarker for PasskeyEntry {
4322 type Borrowed<'a> = &'a Self;
4323 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4324 value
4325 }
4326 }
4327
4328 unsafe impl fidl::encoding::TypeMarker for PasskeyEntry {
4329 type Owned = Self;
4330
4331 #[inline(always)]
4332 fn inline_align(_context: fidl::encoding::Context) -> usize {
4333 1
4334 }
4335
4336 #[inline(always)]
4337 fn inline_size(_context: fidl::encoding::Context) -> usize {
4338 1
4339 }
4340 }
4341
4342 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PasskeyEntry, D>
4343 for &PasskeyEntry
4344 {
4345 #[inline]
4346 unsafe fn encode(
4347 self,
4348 encoder: &mut fidl::encoding::Encoder<'_, D>,
4349 offset: usize,
4350 _depth: fidl::encoding::Depth,
4351 ) -> fidl::Result<()> {
4352 encoder.debug_check_bounds::<PasskeyEntry>(offset);
4353 encoder.write_num(0u8, offset);
4354 Ok(())
4355 }
4356 }
4357
4358 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PasskeyEntry {
4359 #[inline(always)]
4360 fn new_empty() -> Self {
4361 Self
4362 }
4363
4364 #[inline]
4365 unsafe fn decode(
4366 &mut self,
4367 decoder: &mut fidl::encoding::Decoder<'_, D>,
4368 offset: usize,
4369 _depth: fidl::encoding::Depth,
4370 ) -> fidl::Result<()> {
4371 decoder.debug_check_bounds::<Self>(offset);
4372 match decoder.read_num::<u8>(offset) {
4373 0 => Ok(()),
4374 _ => Err(fidl::Error::Invalid),
4375 }
4376 }
4377 }
4378
4379 impl fidl::encoding::ValueTypeMarker for PeerKey {
4380 type Borrowed<'a> = &'a Self;
4381 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4382 value
4383 }
4384 }
4385
4386 unsafe impl fidl::encoding::TypeMarker for PeerKey {
4387 type Owned = Self;
4388
4389 #[inline(always)]
4390 fn inline_align(_context: fidl::encoding::Context) -> usize {
4391 1
4392 }
4393
4394 #[inline(always)]
4395 fn inline_size(_context: fidl::encoding::Context) -> usize {
4396 19
4397 }
4398 }
4399
4400 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PeerKey, D> for &PeerKey {
4401 #[inline]
4402 unsafe fn encode(
4403 self,
4404 encoder: &mut fidl::encoding::Encoder<'_, D>,
4405 offset: usize,
4406 _depth: fidl::encoding::Depth,
4407 ) -> fidl::Result<()> {
4408 encoder.debug_check_bounds::<PeerKey>(offset);
4409 fidl::encoding::Encode::<PeerKey, D>::encode(
4411 (
4412 <SecurityProperties as fidl::encoding::ValueTypeMarker>::borrow(&self.security),
4413 <Key as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
4414 ),
4415 encoder,
4416 offset,
4417 _depth,
4418 )
4419 }
4420 }
4421 unsafe impl<
4422 D: fidl::encoding::ResourceDialect,
4423 T0: fidl::encoding::Encode<SecurityProperties, D>,
4424 T1: fidl::encoding::Encode<Key, D>,
4425 > fidl::encoding::Encode<PeerKey, D> for (T0, T1)
4426 {
4427 #[inline]
4428 unsafe fn encode(
4429 self,
4430 encoder: &mut fidl::encoding::Encoder<'_, D>,
4431 offset: usize,
4432 depth: fidl::encoding::Depth,
4433 ) -> fidl::Result<()> {
4434 encoder.debug_check_bounds::<PeerKey>(offset);
4435 self.0.encode(encoder, offset + 0, depth)?;
4439 self.1.encode(encoder, offset + 3, depth)?;
4440 Ok(())
4441 }
4442 }
4443
4444 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeerKey {
4445 #[inline(always)]
4446 fn new_empty() -> Self {
4447 Self {
4448 security: fidl::new_empty!(SecurityProperties, D),
4449 data: fidl::new_empty!(Key, D),
4450 }
4451 }
4452
4453 #[inline]
4454 unsafe fn decode(
4455 &mut self,
4456 decoder: &mut fidl::encoding::Decoder<'_, D>,
4457 offset: usize,
4458 _depth: fidl::encoding::Depth,
4459 ) -> fidl::Result<()> {
4460 decoder.debug_check_bounds::<Self>(offset);
4461 fidl::decode!(SecurityProperties, D, &mut self.security, decoder, offset + 0, _depth)?;
4463 fidl::decode!(Key, D, &mut self.data, decoder, offset + 3, _depth)?;
4464 Ok(())
4465 }
4466 }
4467
4468 impl fidl::encoding::ValueTypeMarker for SecurityProperties {
4469 type Borrowed<'a> = &'a Self;
4470 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4471 value
4472 }
4473 }
4474
4475 unsafe impl fidl::encoding::TypeMarker for SecurityProperties {
4476 type Owned = Self;
4477
4478 #[inline(always)]
4479 fn inline_align(_context: fidl::encoding::Context) -> usize {
4480 1
4481 }
4482
4483 #[inline(always)]
4484 fn inline_size(_context: fidl::encoding::Context) -> usize {
4485 3
4486 }
4487 }
4488
4489 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecurityProperties, D>
4490 for &SecurityProperties
4491 {
4492 #[inline]
4493 unsafe fn encode(
4494 self,
4495 encoder: &mut fidl::encoding::Encoder<'_, D>,
4496 offset: usize,
4497 _depth: fidl::encoding::Depth,
4498 ) -> fidl::Result<()> {
4499 encoder.debug_check_bounds::<SecurityProperties>(offset);
4500 fidl::encoding::Encode::<SecurityProperties, D>::encode(
4502 (
4503 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.authenticated),
4504 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.secure_connections),
4505 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.encryption_key_size),
4506 ),
4507 encoder,
4508 offset,
4509 _depth,
4510 )
4511 }
4512 }
4513 unsafe impl<
4514 D: fidl::encoding::ResourceDialect,
4515 T0: fidl::encoding::Encode<bool, D>,
4516 T1: fidl::encoding::Encode<bool, D>,
4517 T2: fidl::encoding::Encode<u8, D>,
4518 > fidl::encoding::Encode<SecurityProperties, D> for (T0, T1, T2)
4519 {
4520 #[inline]
4521 unsafe fn encode(
4522 self,
4523 encoder: &mut fidl::encoding::Encoder<'_, D>,
4524 offset: usize,
4525 depth: fidl::encoding::Depth,
4526 ) -> fidl::Result<()> {
4527 encoder.debug_check_bounds::<SecurityProperties>(offset);
4528 self.0.encode(encoder, offset + 0, depth)?;
4532 self.1.encode(encoder, offset + 1, depth)?;
4533 self.2.encode(encoder, offset + 2, depth)?;
4534 Ok(())
4535 }
4536 }
4537
4538 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecurityProperties {
4539 #[inline(always)]
4540 fn new_empty() -> Self {
4541 Self {
4542 authenticated: fidl::new_empty!(bool, D),
4543 secure_connections: fidl::new_empty!(bool, D),
4544 encryption_key_size: fidl::new_empty!(u8, D),
4545 }
4546 }
4547
4548 #[inline]
4549 unsafe fn decode(
4550 &mut self,
4551 decoder: &mut fidl::encoding::Decoder<'_, D>,
4552 offset: usize,
4553 _depth: fidl::encoding::Depth,
4554 ) -> fidl::Result<()> {
4555 decoder.debug_check_bounds::<Self>(offset);
4556 fidl::decode!(bool, D, &mut self.authenticated, decoder, offset + 0, _depth)?;
4558 fidl::decode!(bool, D, &mut self.secure_connections, decoder, offset + 1, _depth)?;
4559 fidl::decode!(u8, D, &mut self.encryption_key_size, decoder, offset + 2, _depth)?;
4560 Ok(())
4561 }
4562 }
4563
4564 impl AddressLookupLookupRequest {
4565 #[inline(always)]
4566 fn max_ordinal_present(&self) -> u64 {
4567 if let Some(_) = self.peer_id {
4568 return 1;
4569 }
4570 0
4571 }
4572 }
4573
4574 impl fidl::encoding::ValueTypeMarker for AddressLookupLookupRequest {
4575 type Borrowed<'a> = &'a Self;
4576 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4577 value
4578 }
4579 }
4580
4581 unsafe impl fidl::encoding::TypeMarker for AddressLookupLookupRequest {
4582 type Owned = Self;
4583
4584 #[inline(always)]
4585 fn inline_align(_context: fidl::encoding::Context) -> usize {
4586 8
4587 }
4588
4589 #[inline(always)]
4590 fn inline_size(_context: fidl::encoding::Context) -> usize {
4591 16
4592 }
4593 }
4594
4595 unsafe impl<D: fidl::encoding::ResourceDialect>
4596 fidl::encoding::Encode<AddressLookupLookupRequest, D> for &AddressLookupLookupRequest
4597 {
4598 unsafe fn encode(
4599 self,
4600 encoder: &mut fidl::encoding::Encoder<'_, D>,
4601 offset: usize,
4602 mut depth: fidl::encoding::Depth,
4603 ) -> fidl::Result<()> {
4604 encoder.debug_check_bounds::<AddressLookupLookupRequest>(offset);
4605 let max_ordinal: u64 = self.max_ordinal_present();
4607 encoder.write_num(max_ordinal, offset);
4608 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4609 if max_ordinal == 0 {
4611 return Ok(());
4612 }
4613 depth.increment()?;
4614 let envelope_size = 8;
4615 let bytes_len = max_ordinal as usize * envelope_size;
4616 #[allow(unused_variables)]
4617 let offset = encoder.out_of_line_offset(bytes_len);
4618 let mut _prev_end_offset: usize = 0;
4619 if 1 > max_ordinal {
4620 return Ok(());
4621 }
4622
4623 let cur_offset: usize = (1 - 1) * envelope_size;
4626
4627 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4629
4630 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
4635 self.peer_id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
4636 encoder, offset + cur_offset, depth
4637 )?;
4638
4639 _prev_end_offset = cur_offset + envelope_size;
4640
4641 Ok(())
4642 }
4643 }
4644
4645 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4646 for AddressLookupLookupRequest
4647 {
4648 #[inline(always)]
4649 fn new_empty() -> Self {
4650 Self::default()
4651 }
4652
4653 unsafe fn decode(
4654 &mut self,
4655 decoder: &mut fidl::encoding::Decoder<'_, D>,
4656 offset: usize,
4657 mut depth: fidl::encoding::Depth,
4658 ) -> fidl::Result<()> {
4659 decoder.debug_check_bounds::<Self>(offset);
4660 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4661 None => return Err(fidl::Error::NotNullable),
4662 Some(len) => len,
4663 };
4664 if len == 0 {
4666 return Ok(());
4667 };
4668 depth.increment()?;
4669 let envelope_size = 8;
4670 let bytes_len = len * envelope_size;
4671 let offset = decoder.out_of_line_offset(bytes_len)?;
4672 let mut _next_ordinal_to_read = 0;
4674 let mut next_offset = offset;
4675 let end_offset = offset + bytes_len;
4676 _next_ordinal_to_read += 1;
4677 if next_offset >= end_offset {
4678 return Ok(());
4679 }
4680
4681 while _next_ordinal_to_read < 1 {
4683 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4684 _next_ordinal_to_read += 1;
4685 next_offset += envelope_size;
4686 }
4687
4688 let next_out_of_line = decoder.next_out_of_line();
4689 let handles_before = decoder.remaining_handles();
4690 if let Some((inlined, num_bytes, num_handles)) =
4691 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4692 {
4693 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4694 if inlined != (member_inline_size <= 4) {
4695 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4696 }
4697 let inner_offset;
4698 let mut inner_depth = depth.clone();
4699 if inlined {
4700 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4701 inner_offset = next_offset;
4702 } else {
4703 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4704 inner_depth.increment()?;
4705 }
4706 let val_ref = self.peer_id.get_or_insert_with(|| {
4707 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
4708 });
4709 fidl::decode!(
4710 fidl_fuchsia_bluetooth__common::PeerId,
4711 D,
4712 val_ref,
4713 decoder,
4714 inner_offset,
4715 inner_depth
4716 )?;
4717 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4718 {
4719 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4720 }
4721 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4722 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4723 }
4724 }
4725
4726 next_offset += envelope_size;
4727
4728 while next_offset < end_offset {
4730 _next_ordinal_to_read += 1;
4731 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4732 next_offset += envelope_size;
4733 }
4734
4735 Ok(())
4736 }
4737 }
4738
4739 impl BondingData {
4740 #[inline(always)]
4741 fn max_ordinal_present(&self) -> u64 {
4742 if let Some(_) = self.bredr_bond {
4743 return 8;
4744 }
4745 if let Some(_) = self.le_bond {
4746 return 7;
4747 }
4748 if let Some(_) = self.address {
4749 return 6;
4750 }
4751 if let Some(_) = self.name {
4752 return 3;
4753 }
4754 if let Some(_) = self.local_address {
4755 return 2;
4756 }
4757 if let Some(_) = self.identifier {
4758 return 1;
4759 }
4760 0
4761 }
4762 }
4763
4764 impl fidl::encoding::ValueTypeMarker for BondingData {
4765 type Borrowed<'a> = &'a Self;
4766 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4767 value
4768 }
4769 }
4770
4771 unsafe impl fidl::encoding::TypeMarker for BondingData {
4772 type Owned = Self;
4773
4774 #[inline(always)]
4775 fn inline_align(_context: fidl::encoding::Context) -> usize {
4776 8
4777 }
4778
4779 #[inline(always)]
4780 fn inline_size(_context: fidl::encoding::Context) -> usize {
4781 16
4782 }
4783 }
4784
4785 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BondingData, D>
4786 for &BondingData
4787 {
4788 unsafe fn encode(
4789 self,
4790 encoder: &mut fidl::encoding::Encoder<'_, D>,
4791 offset: usize,
4792 mut depth: fidl::encoding::Depth,
4793 ) -> fidl::Result<()> {
4794 encoder.debug_check_bounds::<BondingData>(offset);
4795 let max_ordinal: u64 = self.max_ordinal_present();
4797 encoder.write_num(max_ordinal, offset);
4798 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4799 if max_ordinal == 0 {
4801 return Ok(());
4802 }
4803 depth.increment()?;
4804 let envelope_size = 8;
4805 let bytes_len = max_ordinal as usize * envelope_size;
4806 #[allow(unused_variables)]
4807 let offset = encoder.out_of_line_offset(bytes_len);
4808 let mut _prev_end_offset: usize = 0;
4809 if 1 > max_ordinal {
4810 return Ok(());
4811 }
4812
4813 let cur_offset: usize = (1 - 1) * envelope_size;
4816
4817 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4819
4820 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
4825 self.identifier.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
4826 encoder, offset + cur_offset, depth
4827 )?;
4828
4829 _prev_end_offset = cur_offset + envelope_size;
4830 if 2 > max_ordinal {
4831 return Ok(());
4832 }
4833
4834 let cur_offset: usize = (2 - 1) * envelope_size;
4837
4838 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4840
4841 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Address, D>(
4846 self.local_address.as_ref().map(<fidl_fuchsia_bluetooth__common::Address as fidl::encoding::ValueTypeMarker>::borrow),
4847 encoder, offset + cur_offset, depth
4848 )?;
4849
4850 _prev_end_offset = cur_offset + envelope_size;
4851 if 3 > max_ordinal {
4852 return Ok(());
4853 }
4854
4855 let cur_offset: usize = (3 - 1) * envelope_size;
4858
4859 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4861
4862 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
4867 self.name.as_ref().map(
4868 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
4869 ),
4870 encoder,
4871 offset + cur_offset,
4872 depth,
4873 )?;
4874
4875 _prev_end_offset = cur_offset + envelope_size;
4876 if 6 > max_ordinal {
4877 return Ok(());
4878 }
4879
4880 let cur_offset: usize = (6 - 1) * envelope_size;
4883
4884 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4886
4887 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Address, D>(
4892 self.address.as_ref().map(<fidl_fuchsia_bluetooth__common::Address as fidl::encoding::ValueTypeMarker>::borrow),
4893 encoder, offset + cur_offset, depth
4894 )?;
4895
4896 _prev_end_offset = cur_offset + envelope_size;
4897 if 7 > max_ordinal {
4898 return Ok(());
4899 }
4900
4901 let cur_offset: usize = (7 - 1) * envelope_size;
4904
4905 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4907
4908 fidl::encoding::encode_in_envelope_optional::<LeBondData, D>(
4913 self.le_bond.as_ref().map(<LeBondData as fidl::encoding::ValueTypeMarker>::borrow),
4914 encoder,
4915 offset + cur_offset,
4916 depth,
4917 )?;
4918
4919 _prev_end_offset = cur_offset + envelope_size;
4920 if 8 > max_ordinal {
4921 return Ok(());
4922 }
4923
4924 let cur_offset: usize = (8 - 1) * envelope_size;
4927
4928 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4930
4931 fidl::encoding::encode_in_envelope_optional::<BredrBondData, D>(
4936 self.bredr_bond
4937 .as_ref()
4938 .map(<BredrBondData as fidl::encoding::ValueTypeMarker>::borrow),
4939 encoder,
4940 offset + cur_offset,
4941 depth,
4942 )?;
4943
4944 _prev_end_offset = cur_offset + envelope_size;
4945
4946 Ok(())
4947 }
4948 }
4949
4950 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BondingData {
4951 #[inline(always)]
4952 fn new_empty() -> Self {
4953 Self::default()
4954 }
4955
4956 unsafe fn decode(
4957 &mut self,
4958 decoder: &mut fidl::encoding::Decoder<'_, D>,
4959 offset: usize,
4960 mut depth: fidl::encoding::Depth,
4961 ) -> fidl::Result<()> {
4962 decoder.debug_check_bounds::<Self>(offset);
4963 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4964 None => return Err(fidl::Error::NotNullable),
4965 Some(len) => len,
4966 };
4967 if len == 0 {
4969 return Ok(());
4970 };
4971 depth.increment()?;
4972 let envelope_size = 8;
4973 let bytes_len = len * envelope_size;
4974 let offset = decoder.out_of_line_offset(bytes_len)?;
4975 let mut _next_ordinal_to_read = 0;
4977 let mut next_offset = offset;
4978 let end_offset = offset + bytes_len;
4979 _next_ordinal_to_read += 1;
4980 if next_offset >= end_offset {
4981 return Ok(());
4982 }
4983
4984 while _next_ordinal_to_read < 1 {
4986 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4987 _next_ordinal_to_read += 1;
4988 next_offset += envelope_size;
4989 }
4990
4991 let next_out_of_line = decoder.next_out_of_line();
4992 let handles_before = decoder.remaining_handles();
4993 if let Some((inlined, num_bytes, num_handles)) =
4994 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4995 {
4996 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4997 if inlined != (member_inline_size <= 4) {
4998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4999 }
5000 let inner_offset;
5001 let mut inner_depth = depth.clone();
5002 if inlined {
5003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5004 inner_offset = next_offset;
5005 } else {
5006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5007 inner_depth.increment()?;
5008 }
5009 let val_ref = self.identifier.get_or_insert_with(|| {
5010 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
5011 });
5012 fidl::decode!(
5013 fidl_fuchsia_bluetooth__common::PeerId,
5014 D,
5015 val_ref,
5016 decoder,
5017 inner_offset,
5018 inner_depth
5019 )?;
5020 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5021 {
5022 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5023 }
5024 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5025 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5026 }
5027 }
5028
5029 next_offset += envelope_size;
5030 _next_ordinal_to_read += 1;
5031 if next_offset >= end_offset {
5032 return Ok(());
5033 }
5034
5035 while _next_ordinal_to_read < 2 {
5037 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5038 _next_ordinal_to_read += 1;
5039 next_offset += envelope_size;
5040 }
5041
5042 let next_out_of_line = decoder.next_out_of_line();
5043 let handles_before = decoder.remaining_handles();
5044 if let Some((inlined, num_bytes, num_handles)) =
5045 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5046 {
5047 let member_inline_size = <fidl_fuchsia_bluetooth__common::Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5048 if inlined != (member_inline_size <= 4) {
5049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5050 }
5051 let inner_offset;
5052 let mut inner_depth = depth.clone();
5053 if inlined {
5054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5055 inner_offset = next_offset;
5056 } else {
5057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5058 inner_depth.increment()?;
5059 }
5060 let val_ref = self.local_address.get_or_insert_with(|| {
5061 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Address, D)
5062 });
5063 fidl::decode!(
5064 fidl_fuchsia_bluetooth__common::Address,
5065 D,
5066 val_ref,
5067 decoder,
5068 inner_offset,
5069 inner_depth
5070 )?;
5071 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5072 {
5073 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5074 }
5075 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5076 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5077 }
5078 }
5079
5080 next_offset += envelope_size;
5081 _next_ordinal_to_read += 1;
5082 if next_offset >= end_offset {
5083 return Ok(());
5084 }
5085
5086 while _next_ordinal_to_read < 3 {
5088 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5089 _next_ordinal_to_read += 1;
5090 next_offset += envelope_size;
5091 }
5092
5093 let next_out_of_line = decoder.next_out_of_line();
5094 let handles_before = decoder.remaining_handles();
5095 if let Some((inlined, num_bytes, num_handles)) =
5096 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5097 {
5098 let member_inline_size =
5099 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
5100 decoder.context,
5101 );
5102 if inlined != (member_inline_size <= 4) {
5103 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5104 }
5105 let inner_offset;
5106 let mut inner_depth = depth.clone();
5107 if inlined {
5108 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5109 inner_offset = next_offset;
5110 } else {
5111 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5112 inner_depth.increment()?;
5113 }
5114 let val_ref = self
5115 .name
5116 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
5117 fidl::decode!(
5118 fidl::encoding::BoundedString<248>,
5119 D,
5120 val_ref,
5121 decoder,
5122 inner_offset,
5123 inner_depth
5124 )?;
5125 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5126 {
5127 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5128 }
5129 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5130 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5131 }
5132 }
5133
5134 next_offset += envelope_size;
5135 _next_ordinal_to_read += 1;
5136 if next_offset >= end_offset {
5137 return Ok(());
5138 }
5139
5140 while _next_ordinal_to_read < 6 {
5142 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5143 _next_ordinal_to_read += 1;
5144 next_offset += envelope_size;
5145 }
5146
5147 let next_out_of_line = decoder.next_out_of_line();
5148 let handles_before = decoder.remaining_handles();
5149 if let Some((inlined, num_bytes, num_handles)) =
5150 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5151 {
5152 let member_inline_size = <fidl_fuchsia_bluetooth__common::Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5153 if inlined != (member_inline_size <= 4) {
5154 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5155 }
5156 let inner_offset;
5157 let mut inner_depth = depth.clone();
5158 if inlined {
5159 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5160 inner_offset = next_offset;
5161 } else {
5162 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5163 inner_depth.increment()?;
5164 }
5165 let val_ref = self.address.get_or_insert_with(|| {
5166 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Address, D)
5167 });
5168 fidl::decode!(
5169 fidl_fuchsia_bluetooth__common::Address,
5170 D,
5171 val_ref,
5172 decoder,
5173 inner_offset,
5174 inner_depth
5175 )?;
5176 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5177 {
5178 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5179 }
5180 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5181 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5182 }
5183 }
5184
5185 next_offset += envelope_size;
5186 _next_ordinal_to_read += 1;
5187 if next_offset >= end_offset {
5188 return Ok(());
5189 }
5190
5191 while _next_ordinal_to_read < 7 {
5193 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5194 _next_ordinal_to_read += 1;
5195 next_offset += envelope_size;
5196 }
5197
5198 let next_out_of_line = decoder.next_out_of_line();
5199 let handles_before = decoder.remaining_handles();
5200 if let Some((inlined, num_bytes, num_handles)) =
5201 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5202 {
5203 let member_inline_size =
5204 <LeBondData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5205 if inlined != (member_inline_size <= 4) {
5206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5207 }
5208 let inner_offset;
5209 let mut inner_depth = depth.clone();
5210 if inlined {
5211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5212 inner_offset = next_offset;
5213 } else {
5214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5215 inner_depth.increment()?;
5216 }
5217 let val_ref = self.le_bond.get_or_insert_with(|| fidl::new_empty!(LeBondData, D));
5218 fidl::decode!(LeBondData, D, val_ref, decoder, inner_offset, inner_depth)?;
5219 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5220 {
5221 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5222 }
5223 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5224 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5225 }
5226 }
5227
5228 next_offset += envelope_size;
5229 _next_ordinal_to_read += 1;
5230 if next_offset >= end_offset {
5231 return Ok(());
5232 }
5233
5234 while _next_ordinal_to_read < 8 {
5236 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5237 _next_ordinal_to_read += 1;
5238 next_offset += envelope_size;
5239 }
5240
5241 let next_out_of_line = decoder.next_out_of_line();
5242 let handles_before = decoder.remaining_handles();
5243 if let Some((inlined, num_bytes, num_handles)) =
5244 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5245 {
5246 let member_inline_size =
5247 <BredrBondData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5248 if inlined != (member_inline_size <= 4) {
5249 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5250 }
5251 let inner_offset;
5252 let mut inner_depth = depth.clone();
5253 if inlined {
5254 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5255 inner_offset = next_offset;
5256 } else {
5257 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5258 inner_depth.increment()?;
5259 }
5260 let val_ref =
5261 self.bredr_bond.get_or_insert_with(|| fidl::new_empty!(BredrBondData, D));
5262 fidl::decode!(BredrBondData, D, val_ref, decoder, inner_offset, inner_depth)?;
5263 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5264 {
5265 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5266 }
5267 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5268 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5269 }
5270 }
5271
5272 next_offset += envelope_size;
5273
5274 while next_offset < end_offset {
5276 _next_ordinal_to_read += 1;
5277 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5278 next_offset += envelope_size;
5279 }
5280
5281 Ok(())
5282 }
5283 }
5284
5285 impl BredrBondData {
5286 #[inline(always)]
5287 fn max_ordinal_present(&self) -> u64 {
5288 if let Some(_) = self.link_key {
5289 return 3;
5290 }
5291 if let Some(_) = self.services {
5292 return 2;
5293 }
5294 if let Some(_) = self.role_preference {
5295 return 1;
5296 }
5297 0
5298 }
5299 }
5300
5301 impl fidl::encoding::ValueTypeMarker for BredrBondData {
5302 type Borrowed<'a> = &'a Self;
5303 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5304 value
5305 }
5306 }
5307
5308 unsafe impl fidl::encoding::TypeMarker for BredrBondData {
5309 type Owned = Self;
5310
5311 #[inline(always)]
5312 fn inline_align(_context: fidl::encoding::Context) -> usize {
5313 8
5314 }
5315
5316 #[inline(always)]
5317 fn inline_size(_context: fidl::encoding::Context) -> usize {
5318 16
5319 }
5320 }
5321
5322 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BredrBondData, D>
5323 for &BredrBondData
5324 {
5325 unsafe fn encode(
5326 self,
5327 encoder: &mut fidl::encoding::Encoder<'_, D>,
5328 offset: usize,
5329 mut depth: fidl::encoding::Depth,
5330 ) -> fidl::Result<()> {
5331 encoder.debug_check_bounds::<BredrBondData>(offset);
5332 let max_ordinal: u64 = self.max_ordinal_present();
5334 encoder.write_num(max_ordinal, offset);
5335 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5336 if max_ordinal == 0 {
5338 return Ok(());
5339 }
5340 depth.increment()?;
5341 let envelope_size = 8;
5342 let bytes_len = max_ordinal as usize * envelope_size;
5343 #[allow(unused_variables)]
5344 let offset = encoder.out_of_line_offset(bytes_len);
5345 let mut _prev_end_offset: usize = 0;
5346 if 1 > max_ordinal {
5347 return Ok(());
5348 }
5349
5350 let cur_offset: usize = (1 - 1) * envelope_size;
5353
5354 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5356
5357 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::ConnectionRole, D>(
5362 self.role_preference.as_ref().map(<fidl_fuchsia_bluetooth__common::ConnectionRole as fidl::encoding::ValueTypeMarker>::borrow),
5363 encoder, offset + cur_offset, depth
5364 )?;
5365
5366 _prev_end_offset = cur_offset + envelope_size;
5367 if 2 > max_ordinal {
5368 return Ok(());
5369 }
5370
5371 let cur_offset: usize = (2 - 1) * envelope_size;
5374
5375 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5377
5378 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D>(
5383 self.services.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535> as fidl::encoding::ValueTypeMarker>::borrow),
5384 encoder, offset + cur_offset, depth
5385 )?;
5386
5387 _prev_end_offset = cur_offset + envelope_size;
5388 if 3 > max_ordinal {
5389 return Ok(());
5390 }
5391
5392 let cur_offset: usize = (3 - 1) * envelope_size;
5395
5396 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5398
5399 fidl::encoding::encode_in_envelope_optional::<PeerKey, D>(
5404 self.link_key.as_ref().map(<PeerKey as fidl::encoding::ValueTypeMarker>::borrow),
5405 encoder,
5406 offset + cur_offset,
5407 depth,
5408 )?;
5409
5410 _prev_end_offset = cur_offset + envelope_size;
5411
5412 Ok(())
5413 }
5414 }
5415
5416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BredrBondData {
5417 #[inline(always)]
5418 fn new_empty() -> Self {
5419 Self::default()
5420 }
5421
5422 unsafe fn decode(
5423 &mut self,
5424 decoder: &mut fidl::encoding::Decoder<'_, D>,
5425 offset: usize,
5426 mut depth: fidl::encoding::Depth,
5427 ) -> fidl::Result<()> {
5428 decoder.debug_check_bounds::<Self>(offset);
5429 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5430 None => return Err(fidl::Error::NotNullable),
5431 Some(len) => len,
5432 };
5433 if len == 0 {
5435 return Ok(());
5436 };
5437 depth.increment()?;
5438 let envelope_size = 8;
5439 let bytes_len = len * envelope_size;
5440 let offset = decoder.out_of_line_offset(bytes_len)?;
5441 let mut _next_ordinal_to_read = 0;
5443 let mut next_offset = offset;
5444 let end_offset = offset + bytes_len;
5445 _next_ordinal_to_read += 1;
5446 if next_offset >= end_offset {
5447 return Ok(());
5448 }
5449
5450 while _next_ordinal_to_read < 1 {
5452 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5453 _next_ordinal_to_read += 1;
5454 next_offset += envelope_size;
5455 }
5456
5457 let next_out_of_line = decoder.next_out_of_line();
5458 let handles_before = decoder.remaining_handles();
5459 if let Some((inlined, num_bytes, num_handles)) =
5460 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5461 {
5462 let member_inline_size = <fidl_fuchsia_bluetooth__common::ConnectionRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5463 if inlined != (member_inline_size <= 4) {
5464 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5465 }
5466 let inner_offset;
5467 let mut inner_depth = depth.clone();
5468 if inlined {
5469 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5470 inner_offset = next_offset;
5471 } else {
5472 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5473 inner_depth.increment()?;
5474 }
5475 let val_ref = self.role_preference.get_or_insert_with(|| {
5476 fidl::new_empty!(fidl_fuchsia_bluetooth__common::ConnectionRole, D)
5477 });
5478 fidl::decode!(
5479 fidl_fuchsia_bluetooth__common::ConnectionRole,
5480 D,
5481 val_ref,
5482 decoder,
5483 inner_offset,
5484 inner_depth
5485 )?;
5486 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5487 {
5488 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5489 }
5490 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5491 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5492 }
5493 }
5494
5495 next_offset += envelope_size;
5496 _next_ordinal_to_read += 1;
5497 if next_offset >= end_offset {
5498 return Ok(());
5499 }
5500
5501 while _next_ordinal_to_read < 2 {
5503 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5504 _next_ordinal_to_read += 1;
5505 next_offset += envelope_size;
5506 }
5507
5508 let next_out_of_line = decoder.next_out_of_line();
5509 let handles_before = decoder.remaining_handles();
5510 if let Some((inlined, num_bytes, num_handles)) =
5511 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5512 {
5513 let member_inline_size = <fidl::encoding::Vector<
5514 fidl_fuchsia_bluetooth__common::Uuid,
5515 65535,
5516 > as fidl::encoding::TypeMarker>::inline_size(
5517 decoder.context
5518 );
5519 if inlined != (member_inline_size <= 4) {
5520 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5521 }
5522 let inner_offset;
5523 let mut inner_depth = depth.clone();
5524 if inlined {
5525 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5526 inner_offset = next_offset;
5527 } else {
5528 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5529 inner_depth.increment()?;
5530 }
5531 let val_ref =
5532 self.services.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D));
5533 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D, val_ref, decoder, inner_offset, inner_depth)?;
5534 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5535 {
5536 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5537 }
5538 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5539 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5540 }
5541 }
5542
5543 next_offset += envelope_size;
5544 _next_ordinal_to_read += 1;
5545 if next_offset >= end_offset {
5546 return Ok(());
5547 }
5548
5549 while _next_ordinal_to_read < 3 {
5551 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5552 _next_ordinal_to_read += 1;
5553 next_offset += envelope_size;
5554 }
5555
5556 let next_out_of_line = decoder.next_out_of_line();
5557 let handles_before = decoder.remaining_handles();
5558 if let Some((inlined, num_bytes, num_handles)) =
5559 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5560 {
5561 let member_inline_size =
5562 <PeerKey as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5563 if inlined != (member_inline_size <= 4) {
5564 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5565 }
5566 let inner_offset;
5567 let mut inner_depth = depth.clone();
5568 if inlined {
5569 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5570 inner_offset = next_offset;
5571 } else {
5572 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5573 inner_depth.increment()?;
5574 }
5575 let val_ref = self.link_key.get_or_insert_with(|| fidl::new_empty!(PeerKey, D));
5576 fidl::decode!(PeerKey, D, val_ref, decoder, inner_offset, inner_depth)?;
5577 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5578 {
5579 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5580 }
5581 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5582 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5583 }
5584 }
5585
5586 next_offset += envelope_size;
5587
5588 while next_offset < end_offset {
5590 _next_ordinal_to_read += 1;
5591 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5592 next_offset += envelope_size;
5593 }
5594
5595 Ok(())
5596 }
5597 }
5598
5599 impl HostData {
5600 #[inline(always)]
5601 fn max_ordinal_present(&self) -> u64 {
5602 if let Some(_) = self.irk {
5603 return 1;
5604 }
5605 0
5606 }
5607 }
5608
5609 impl fidl::encoding::ValueTypeMarker for HostData {
5610 type Borrowed<'a> = &'a Self;
5611 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5612 value
5613 }
5614 }
5615
5616 unsafe impl fidl::encoding::TypeMarker for HostData {
5617 type Owned = Self;
5618
5619 #[inline(always)]
5620 fn inline_align(_context: fidl::encoding::Context) -> usize {
5621 8
5622 }
5623
5624 #[inline(always)]
5625 fn inline_size(_context: fidl::encoding::Context) -> usize {
5626 16
5627 }
5628 }
5629
5630 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HostData, D> for &HostData {
5631 unsafe fn encode(
5632 self,
5633 encoder: &mut fidl::encoding::Encoder<'_, D>,
5634 offset: usize,
5635 mut depth: fidl::encoding::Depth,
5636 ) -> fidl::Result<()> {
5637 encoder.debug_check_bounds::<HostData>(offset);
5638 let max_ordinal: u64 = self.max_ordinal_present();
5640 encoder.write_num(max_ordinal, offset);
5641 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5642 if max_ordinal == 0 {
5644 return Ok(());
5645 }
5646 depth.increment()?;
5647 let envelope_size = 8;
5648 let bytes_len = max_ordinal as usize * envelope_size;
5649 #[allow(unused_variables)]
5650 let offset = encoder.out_of_line_offset(bytes_len);
5651 let mut _prev_end_offset: usize = 0;
5652 if 1 > max_ordinal {
5653 return Ok(());
5654 }
5655
5656 let cur_offset: usize = (1 - 1) * envelope_size;
5659
5660 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5662
5663 fidl::encoding::encode_in_envelope_optional::<Key, D>(
5668 self.irk.as_ref().map(<Key as fidl::encoding::ValueTypeMarker>::borrow),
5669 encoder,
5670 offset + cur_offset,
5671 depth,
5672 )?;
5673
5674 _prev_end_offset = cur_offset + envelope_size;
5675
5676 Ok(())
5677 }
5678 }
5679
5680 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HostData {
5681 #[inline(always)]
5682 fn new_empty() -> Self {
5683 Self::default()
5684 }
5685
5686 unsafe fn decode(
5687 &mut self,
5688 decoder: &mut fidl::encoding::Decoder<'_, D>,
5689 offset: usize,
5690 mut depth: fidl::encoding::Depth,
5691 ) -> fidl::Result<()> {
5692 decoder.debug_check_bounds::<Self>(offset);
5693 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5694 None => return Err(fidl::Error::NotNullable),
5695 Some(len) => len,
5696 };
5697 if len == 0 {
5699 return Ok(());
5700 };
5701 depth.increment()?;
5702 let envelope_size = 8;
5703 let bytes_len = len * envelope_size;
5704 let offset = decoder.out_of_line_offset(bytes_len)?;
5705 let mut _next_ordinal_to_read = 0;
5707 let mut next_offset = offset;
5708 let end_offset = offset + bytes_len;
5709 _next_ordinal_to_read += 1;
5710 if next_offset >= end_offset {
5711 return Ok(());
5712 }
5713
5714 while _next_ordinal_to_read < 1 {
5716 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5717 _next_ordinal_to_read += 1;
5718 next_offset += envelope_size;
5719 }
5720
5721 let next_out_of_line = decoder.next_out_of_line();
5722 let handles_before = decoder.remaining_handles();
5723 if let Some((inlined, num_bytes, num_handles)) =
5724 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5725 {
5726 let member_inline_size =
5727 <Key as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5728 if inlined != (member_inline_size <= 4) {
5729 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5730 }
5731 let inner_offset;
5732 let mut inner_depth = depth.clone();
5733 if inlined {
5734 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5735 inner_offset = next_offset;
5736 } else {
5737 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5738 inner_depth.increment()?;
5739 }
5740 let val_ref = self.irk.get_or_insert_with(|| fidl::new_empty!(Key, D));
5741 fidl::decode!(Key, D, val_ref, decoder, inner_offset, inner_depth)?;
5742 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5743 {
5744 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5745 }
5746 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5747 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5748 }
5749 }
5750
5751 next_offset += envelope_size;
5752
5753 while next_offset < end_offset {
5755 _next_ordinal_to_read += 1;
5756 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5757 next_offset += envelope_size;
5758 }
5759
5760 Ok(())
5761 }
5762 }
5763
5764 impl HostInfo {
5765 #[inline(always)]
5766 fn max_ordinal_present(&self) -> u64 {
5767 if let Some(_) = self.addresses {
5768 return 8;
5769 }
5770 if let Some(_) = self.discovering {
5771 return 7;
5772 }
5773 if let Some(_) = self.discoverable {
5774 return 6;
5775 }
5776 if let Some(_) = self.local_name {
5777 return 5;
5778 }
5779 if let Some(_) = self.active {
5780 return 4;
5781 }
5782 if let Some(_) = self.technology {
5783 return 2;
5784 }
5785 if let Some(_) = self.id {
5786 return 1;
5787 }
5788 0
5789 }
5790 }
5791
5792 impl fidl::encoding::ValueTypeMarker for HostInfo {
5793 type Borrowed<'a> = &'a Self;
5794 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5795 value
5796 }
5797 }
5798
5799 unsafe impl fidl::encoding::TypeMarker for HostInfo {
5800 type Owned = Self;
5801
5802 #[inline(always)]
5803 fn inline_align(_context: fidl::encoding::Context) -> usize {
5804 8
5805 }
5806
5807 #[inline(always)]
5808 fn inline_size(_context: fidl::encoding::Context) -> usize {
5809 16
5810 }
5811 }
5812
5813 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HostInfo, D> for &HostInfo {
5814 unsafe fn encode(
5815 self,
5816 encoder: &mut fidl::encoding::Encoder<'_, D>,
5817 offset: usize,
5818 mut depth: fidl::encoding::Depth,
5819 ) -> fidl::Result<()> {
5820 encoder.debug_check_bounds::<HostInfo>(offset);
5821 let max_ordinal: u64 = self.max_ordinal_present();
5823 encoder.write_num(max_ordinal, offset);
5824 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5825 if max_ordinal == 0 {
5827 return Ok(());
5828 }
5829 depth.increment()?;
5830 let envelope_size = 8;
5831 let bytes_len = max_ordinal as usize * envelope_size;
5832 #[allow(unused_variables)]
5833 let offset = encoder.out_of_line_offset(bytes_len);
5834 let mut _prev_end_offset: usize = 0;
5835 if 1 > max_ordinal {
5836 return Ok(());
5837 }
5838
5839 let cur_offset: usize = (1 - 1) * envelope_size;
5842
5843 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5845
5846 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::HostId, D>(
5851 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::HostId as fidl::encoding::ValueTypeMarker>::borrow),
5852 encoder, offset + cur_offset, depth
5853 )?;
5854
5855 _prev_end_offset = cur_offset + envelope_size;
5856 if 2 > max_ordinal {
5857 return Ok(());
5858 }
5859
5860 let cur_offset: usize = (2 - 1) * envelope_size;
5863
5864 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5866
5867 fidl::encoding::encode_in_envelope_optional::<TechnologyType, D>(
5872 self.technology
5873 .as_ref()
5874 .map(<TechnologyType as fidl::encoding::ValueTypeMarker>::borrow),
5875 encoder,
5876 offset + cur_offset,
5877 depth,
5878 )?;
5879
5880 _prev_end_offset = cur_offset + envelope_size;
5881 if 4 > max_ordinal {
5882 return Ok(());
5883 }
5884
5885 let cur_offset: usize = (4 - 1) * envelope_size;
5888
5889 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5891
5892 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5897 self.active.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5898 encoder,
5899 offset + cur_offset,
5900 depth,
5901 )?;
5902
5903 _prev_end_offset = cur_offset + envelope_size;
5904 if 5 > max_ordinal {
5905 return Ok(());
5906 }
5907
5908 let cur_offset: usize = (5 - 1) * envelope_size;
5911
5912 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5914
5915 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
5920 self.local_name.as_ref().map(
5921 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
5922 ),
5923 encoder,
5924 offset + cur_offset,
5925 depth,
5926 )?;
5927
5928 _prev_end_offset = cur_offset + envelope_size;
5929 if 6 > max_ordinal {
5930 return Ok(());
5931 }
5932
5933 let cur_offset: usize = (6 - 1) * envelope_size;
5936
5937 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5939
5940 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5945 self.discoverable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5946 encoder,
5947 offset + cur_offset,
5948 depth,
5949 )?;
5950
5951 _prev_end_offset = cur_offset + envelope_size;
5952 if 7 > max_ordinal {
5953 return Ok(());
5954 }
5955
5956 let cur_offset: usize = (7 - 1) * envelope_size;
5959
5960 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5962
5963 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5968 self.discovering.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5969 encoder,
5970 offset + cur_offset,
5971 depth,
5972 )?;
5973
5974 _prev_end_offset = cur_offset + envelope_size;
5975 if 8 > max_ordinal {
5976 return Ok(());
5977 }
5978
5979 let cur_offset: usize = (8 - 1) * envelope_size;
5982
5983 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5985
5986 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Address>, D>(
5991 self.addresses.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Address> as fidl::encoding::ValueTypeMarker>::borrow),
5992 encoder, offset + cur_offset, depth
5993 )?;
5994
5995 _prev_end_offset = cur_offset + envelope_size;
5996
5997 Ok(())
5998 }
5999 }
6000
6001 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HostInfo {
6002 #[inline(always)]
6003 fn new_empty() -> Self {
6004 Self::default()
6005 }
6006
6007 unsafe fn decode(
6008 &mut self,
6009 decoder: &mut fidl::encoding::Decoder<'_, D>,
6010 offset: usize,
6011 mut depth: fidl::encoding::Depth,
6012 ) -> fidl::Result<()> {
6013 decoder.debug_check_bounds::<Self>(offset);
6014 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6015 None => return Err(fidl::Error::NotNullable),
6016 Some(len) => len,
6017 };
6018 if len == 0 {
6020 return Ok(());
6021 };
6022 depth.increment()?;
6023 let envelope_size = 8;
6024 let bytes_len = len * envelope_size;
6025 let offset = decoder.out_of_line_offset(bytes_len)?;
6026 let mut _next_ordinal_to_read = 0;
6028 let mut next_offset = offset;
6029 let end_offset = offset + bytes_len;
6030 _next_ordinal_to_read += 1;
6031 if next_offset >= end_offset {
6032 return Ok(());
6033 }
6034
6035 while _next_ordinal_to_read < 1 {
6037 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6038 _next_ordinal_to_read += 1;
6039 next_offset += envelope_size;
6040 }
6041
6042 let next_out_of_line = decoder.next_out_of_line();
6043 let handles_before = decoder.remaining_handles();
6044 if let Some((inlined, num_bytes, num_handles)) =
6045 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6046 {
6047 let member_inline_size = <fidl_fuchsia_bluetooth__common::HostId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6048 if inlined != (member_inline_size <= 4) {
6049 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6050 }
6051 let inner_offset;
6052 let mut inner_depth = depth.clone();
6053 if inlined {
6054 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6055 inner_offset = next_offset;
6056 } else {
6057 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6058 inner_depth.increment()?;
6059 }
6060 let val_ref = self.id.get_or_insert_with(|| {
6061 fidl::new_empty!(fidl_fuchsia_bluetooth__common::HostId, D)
6062 });
6063 fidl::decode!(
6064 fidl_fuchsia_bluetooth__common::HostId,
6065 D,
6066 val_ref,
6067 decoder,
6068 inner_offset,
6069 inner_depth
6070 )?;
6071 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6072 {
6073 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6074 }
6075 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6076 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6077 }
6078 }
6079
6080 next_offset += envelope_size;
6081 _next_ordinal_to_read += 1;
6082 if next_offset >= end_offset {
6083 return Ok(());
6084 }
6085
6086 while _next_ordinal_to_read < 2 {
6088 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6089 _next_ordinal_to_read += 1;
6090 next_offset += envelope_size;
6091 }
6092
6093 let next_out_of_line = decoder.next_out_of_line();
6094 let handles_before = decoder.remaining_handles();
6095 if let Some((inlined, num_bytes, num_handles)) =
6096 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6097 {
6098 let member_inline_size =
6099 <TechnologyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6100 if inlined != (member_inline_size <= 4) {
6101 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6102 }
6103 let inner_offset;
6104 let mut inner_depth = depth.clone();
6105 if inlined {
6106 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6107 inner_offset = next_offset;
6108 } else {
6109 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6110 inner_depth.increment()?;
6111 }
6112 let val_ref =
6113 self.technology.get_or_insert_with(|| fidl::new_empty!(TechnologyType, D));
6114 fidl::decode!(TechnologyType, D, val_ref, decoder, inner_offset, inner_depth)?;
6115 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6116 {
6117 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6118 }
6119 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6120 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6121 }
6122 }
6123
6124 next_offset += envelope_size;
6125 _next_ordinal_to_read += 1;
6126 if next_offset >= end_offset {
6127 return Ok(());
6128 }
6129
6130 while _next_ordinal_to_read < 4 {
6132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6133 _next_ordinal_to_read += 1;
6134 next_offset += envelope_size;
6135 }
6136
6137 let next_out_of_line = decoder.next_out_of_line();
6138 let handles_before = decoder.remaining_handles();
6139 if let Some((inlined, num_bytes, num_handles)) =
6140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6141 {
6142 let member_inline_size =
6143 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6144 if inlined != (member_inline_size <= 4) {
6145 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6146 }
6147 let inner_offset;
6148 let mut inner_depth = depth.clone();
6149 if inlined {
6150 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6151 inner_offset = next_offset;
6152 } else {
6153 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6154 inner_depth.increment()?;
6155 }
6156 let val_ref = self.active.get_or_insert_with(|| fidl::new_empty!(bool, D));
6157 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6158 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6159 {
6160 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6161 }
6162 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6163 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6164 }
6165 }
6166
6167 next_offset += envelope_size;
6168 _next_ordinal_to_read += 1;
6169 if next_offset >= end_offset {
6170 return Ok(());
6171 }
6172
6173 while _next_ordinal_to_read < 5 {
6175 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6176 _next_ordinal_to_read += 1;
6177 next_offset += envelope_size;
6178 }
6179
6180 let next_out_of_line = decoder.next_out_of_line();
6181 let handles_before = decoder.remaining_handles();
6182 if let Some((inlined, num_bytes, num_handles)) =
6183 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6184 {
6185 let member_inline_size =
6186 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
6187 decoder.context,
6188 );
6189 if inlined != (member_inline_size <= 4) {
6190 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6191 }
6192 let inner_offset;
6193 let mut inner_depth = depth.clone();
6194 if inlined {
6195 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6196 inner_offset = next_offset;
6197 } else {
6198 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6199 inner_depth.increment()?;
6200 }
6201 let val_ref = self
6202 .local_name
6203 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
6204 fidl::decode!(
6205 fidl::encoding::BoundedString<248>,
6206 D,
6207 val_ref,
6208 decoder,
6209 inner_offset,
6210 inner_depth
6211 )?;
6212 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6213 {
6214 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6215 }
6216 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6217 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6218 }
6219 }
6220
6221 next_offset += envelope_size;
6222 _next_ordinal_to_read += 1;
6223 if next_offset >= end_offset {
6224 return Ok(());
6225 }
6226
6227 while _next_ordinal_to_read < 6 {
6229 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6230 _next_ordinal_to_read += 1;
6231 next_offset += envelope_size;
6232 }
6233
6234 let next_out_of_line = decoder.next_out_of_line();
6235 let handles_before = decoder.remaining_handles();
6236 if let Some((inlined, num_bytes, num_handles)) =
6237 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6238 {
6239 let member_inline_size =
6240 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6241 if inlined != (member_inline_size <= 4) {
6242 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6243 }
6244 let inner_offset;
6245 let mut inner_depth = depth.clone();
6246 if inlined {
6247 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6248 inner_offset = next_offset;
6249 } else {
6250 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6251 inner_depth.increment()?;
6252 }
6253 let val_ref = self.discoverable.get_or_insert_with(|| fidl::new_empty!(bool, D));
6254 fidl::decode!(bool, 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 < 7 {
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 <bool 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 = self.discovering.get_or_insert_with(|| fidl::new_empty!(bool, D));
6297 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6298 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6299 {
6300 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6301 }
6302 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6303 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6304 }
6305 }
6306
6307 next_offset += envelope_size;
6308 _next_ordinal_to_read += 1;
6309 if next_offset >= end_offset {
6310 return Ok(());
6311 }
6312
6313 while _next_ordinal_to_read < 8 {
6315 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6316 _next_ordinal_to_read += 1;
6317 next_offset += envelope_size;
6318 }
6319
6320 let next_out_of_line = decoder.next_out_of_line();
6321 let handles_before = decoder.remaining_handles();
6322 if let Some((inlined, num_bytes, num_handles)) =
6323 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6324 {
6325 let member_inline_size = <fidl::encoding::UnboundedVector<
6326 fidl_fuchsia_bluetooth__common::Address,
6327 > as fidl::encoding::TypeMarker>::inline_size(
6328 decoder.context
6329 );
6330 if inlined != (member_inline_size <= 4) {
6331 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6332 }
6333 let inner_offset;
6334 let mut inner_depth = depth.clone();
6335 if inlined {
6336 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6337 inner_offset = next_offset;
6338 } else {
6339 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6340 inner_depth.increment()?;
6341 }
6342 let val_ref = self.addresses.get_or_insert_with(|| {
6343 fidl::new_empty!(
6344 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Address>,
6345 D
6346 )
6347 });
6348 fidl::decode!(
6349 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Address>,
6350 D,
6351 val_ref,
6352 decoder,
6353 inner_offset,
6354 inner_depth
6355 )?;
6356 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6357 {
6358 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6359 }
6360 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6361 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6362 }
6363 }
6364
6365 next_offset += envelope_size;
6366
6367 while next_offset < end_offset {
6369 _next_ordinal_to_read += 1;
6370 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6371 next_offset += envelope_size;
6372 }
6373
6374 Ok(())
6375 }
6376 }
6377
6378 impl Identity {
6379 #[inline(always)]
6380 fn max_ordinal_present(&self) -> u64 {
6381 if let Some(_) = self.bonds {
6382 return 2;
6383 }
6384 if let Some(_) = self.host {
6385 return 1;
6386 }
6387 0
6388 }
6389 }
6390
6391 impl fidl::encoding::ValueTypeMarker for Identity {
6392 type Borrowed<'a> = &'a Self;
6393 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6394 value
6395 }
6396 }
6397
6398 unsafe impl fidl::encoding::TypeMarker for Identity {
6399 type Owned = Self;
6400
6401 #[inline(always)]
6402 fn inline_align(_context: fidl::encoding::Context) -> usize {
6403 8
6404 }
6405
6406 #[inline(always)]
6407 fn inline_size(_context: fidl::encoding::Context) -> usize {
6408 16
6409 }
6410 }
6411
6412 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Identity, D> for &Identity {
6413 unsafe fn encode(
6414 self,
6415 encoder: &mut fidl::encoding::Encoder<'_, D>,
6416 offset: usize,
6417 mut depth: fidl::encoding::Depth,
6418 ) -> fidl::Result<()> {
6419 encoder.debug_check_bounds::<Identity>(offset);
6420 let max_ordinal: u64 = self.max_ordinal_present();
6422 encoder.write_num(max_ordinal, offset);
6423 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6424 if max_ordinal == 0 {
6426 return Ok(());
6427 }
6428 depth.increment()?;
6429 let envelope_size = 8;
6430 let bytes_len = max_ordinal as usize * envelope_size;
6431 #[allow(unused_variables)]
6432 let offset = encoder.out_of_line_offset(bytes_len);
6433 let mut _prev_end_offset: usize = 0;
6434 if 1 > max_ordinal {
6435 return Ok(());
6436 }
6437
6438 let cur_offset: usize = (1 - 1) * envelope_size;
6441
6442 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6444
6445 fidl::encoding::encode_in_envelope_optional::<HostData, D>(
6450 self.host.as_ref().map(<HostData as fidl::encoding::ValueTypeMarker>::borrow),
6451 encoder,
6452 offset + cur_offset,
6453 depth,
6454 )?;
6455
6456 _prev_end_offset = cur_offset + envelope_size;
6457 if 2 > max_ordinal {
6458 return Ok(());
6459 }
6460
6461 let cur_offset: usize = (2 - 1) * envelope_size;
6464
6465 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6467
6468 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<BondingData>, D>(
6473 self.bonds.as_ref().map(<fidl::encoding::UnboundedVector<BondingData> as fidl::encoding::ValueTypeMarker>::borrow),
6474 encoder, offset + cur_offset, depth
6475 )?;
6476
6477 _prev_end_offset = cur_offset + envelope_size;
6478
6479 Ok(())
6480 }
6481 }
6482
6483 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Identity {
6484 #[inline(always)]
6485 fn new_empty() -> Self {
6486 Self::default()
6487 }
6488
6489 unsafe fn decode(
6490 &mut self,
6491 decoder: &mut fidl::encoding::Decoder<'_, D>,
6492 offset: usize,
6493 mut depth: fidl::encoding::Depth,
6494 ) -> fidl::Result<()> {
6495 decoder.debug_check_bounds::<Self>(offset);
6496 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6497 None => return Err(fidl::Error::NotNullable),
6498 Some(len) => len,
6499 };
6500 if len == 0 {
6502 return Ok(());
6503 };
6504 depth.increment()?;
6505 let envelope_size = 8;
6506 let bytes_len = len * envelope_size;
6507 let offset = decoder.out_of_line_offset(bytes_len)?;
6508 let mut _next_ordinal_to_read = 0;
6510 let mut next_offset = offset;
6511 let end_offset = offset + bytes_len;
6512 _next_ordinal_to_read += 1;
6513 if next_offset >= end_offset {
6514 return Ok(());
6515 }
6516
6517 while _next_ordinal_to_read < 1 {
6519 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6520 _next_ordinal_to_read += 1;
6521 next_offset += envelope_size;
6522 }
6523
6524 let next_out_of_line = decoder.next_out_of_line();
6525 let handles_before = decoder.remaining_handles();
6526 if let Some((inlined, num_bytes, num_handles)) =
6527 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6528 {
6529 let member_inline_size =
6530 <HostData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6531 if inlined != (member_inline_size <= 4) {
6532 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6533 }
6534 let inner_offset;
6535 let mut inner_depth = depth.clone();
6536 if inlined {
6537 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6538 inner_offset = next_offset;
6539 } else {
6540 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6541 inner_depth.increment()?;
6542 }
6543 let val_ref = self.host.get_or_insert_with(|| fidl::new_empty!(HostData, D));
6544 fidl::decode!(HostData, D, val_ref, decoder, inner_offset, inner_depth)?;
6545 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6546 {
6547 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6548 }
6549 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6550 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6551 }
6552 }
6553
6554 next_offset += envelope_size;
6555 _next_ordinal_to_read += 1;
6556 if next_offset >= end_offset {
6557 return Ok(());
6558 }
6559
6560 while _next_ordinal_to_read < 2 {
6562 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6563 _next_ordinal_to_read += 1;
6564 next_offset += envelope_size;
6565 }
6566
6567 let next_out_of_line = decoder.next_out_of_line();
6568 let handles_before = decoder.remaining_handles();
6569 if let Some((inlined, num_bytes, num_handles)) =
6570 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6571 {
6572 let member_inline_size = <fidl::encoding::UnboundedVector<BondingData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6573 if inlined != (member_inline_size <= 4) {
6574 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6575 }
6576 let inner_offset;
6577 let mut inner_depth = depth.clone();
6578 if inlined {
6579 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6580 inner_offset = next_offset;
6581 } else {
6582 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6583 inner_depth.increment()?;
6584 }
6585 let val_ref = self.bonds.get_or_insert_with(|| {
6586 fidl::new_empty!(fidl::encoding::UnboundedVector<BondingData>, D)
6587 });
6588 fidl::decode!(
6589 fidl::encoding::UnboundedVector<BondingData>,
6590 D,
6591 val_ref,
6592 decoder,
6593 inner_offset,
6594 inner_depth
6595 )?;
6596 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6597 {
6598 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6599 }
6600 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6601 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6602 }
6603 }
6604
6605 next_offset += envelope_size;
6606
6607 while next_offset < end_offset {
6609 _next_ordinal_to_read += 1;
6610 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6611 next_offset += envelope_size;
6612 }
6613
6614 Ok(())
6615 }
6616 }
6617
6618 impl LeBondData {
6619 #[inline(always)]
6620 fn max_ordinal_present(&self) -> u64 {
6621 if let Some(_) = self.local_ltk {
6622 return 6;
6623 }
6624 if let Some(_) = self.peer_ltk {
6625 return 5;
6626 }
6627 if let Some(_) = self.csrk {
6628 return 4;
6629 }
6630 if let Some(_) = self.irk {
6631 return 3;
6632 }
6633 if let Some(_) = self.services {
6634 return 2;
6635 }
6636 if let Some(_) = self.connection_parameters {
6637 return 1;
6638 }
6639 0
6640 }
6641 }
6642
6643 impl fidl::encoding::ValueTypeMarker for LeBondData {
6644 type Borrowed<'a> = &'a Self;
6645 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6646 value
6647 }
6648 }
6649
6650 unsafe impl fidl::encoding::TypeMarker for LeBondData {
6651 type Owned = Self;
6652
6653 #[inline(always)]
6654 fn inline_align(_context: fidl::encoding::Context) -> usize {
6655 8
6656 }
6657
6658 #[inline(always)]
6659 fn inline_size(_context: fidl::encoding::Context) -> usize {
6660 16
6661 }
6662 }
6663
6664 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeBondData, D>
6665 for &LeBondData
6666 {
6667 unsafe fn encode(
6668 self,
6669 encoder: &mut fidl::encoding::Encoder<'_, D>,
6670 offset: usize,
6671 mut depth: fidl::encoding::Depth,
6672 ) -> fidl::Result<()> {
6673 encoder.debug_check_bounds::<LeBondData>(offset);
6674 let max_ordinal: u64 = self.max_ordinal_present();
6676 encoder.write_num(max_ordinal, offset);
6677 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6678 if max_ordinal == 0 {
6680 return Ok(());
6681 }
6682 depth.increment()?;
6683 let envelope_size = 8;
6684 let bytes_len = max_ordinal as usize * envelope_size;
6685 #[allow(unused_variables)]
6686 let offset = encoder.out_of_line_offset(bytes_len);
6687 let mut _prev_end_offset: usize = 0;
6688 if 1 > max_ordinal {
6689 return Ok(());
6690 }
6691
6692 let cur_offset: usize = (1 - 1) * envelope_size;
6695
6696 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6698
6699 fidl::encoding::encode_in_envelope_optional::<LeConnectionParameters, D>(
6704 self.connection_parameters
6705 .as_ref()
6706 .map(<LeConnectionParameters as fidl::encoding::ValueTypeMarker>::borrow),
6707 encoder,
6708 offset + cur_offset,
6709 depth,
6710 )?;
6711
6712 _prev_end_offset = cur_offset + envelope_size;
6713 if 2 > max_ordinal {
6714 return Ok(());
6715 }
6716
6717 let cur_offset: usize = (2 - 1) * envelope_size;
6720
6721 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6723
6724 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D>(
6729 self.services.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535> as fidl::encoding::ValueTypeMarker>::borrow),
6730 encoder, offset + cur_offset, depth
6731 )?;
6732
6733 _prev_end_offset = cur_offset + envelope_size;
6734 if 3 > max_ordinal {
6735 return Ok(());
6736 }
6737
6738 let cur_offset: usize = (3 - 1) * envelope_size;
6741
6742 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6744
6745 fidl::encoding::encode_in_envelope_optional::<PeerKey, D>(
6750 self.irk.as_ref().map(<PeerKey as fidl::encoding::ValueTypeMarker>::borrow),
6751 encoder,
6752 offset + cur_offset,
6753 depth,
6754 )?;
6755
6756 _prev_end_offset = cur_offset + envelope_size;
6757 if 4 > max_ordinal {
6758 return Ok(());
6759 }
6760
6761 let cur_offset: usize = (4 - 1) * envelope_size;
6764
6765 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6767
6768 fidl::encoding::encode_in_envelope_optional::<PeerKey, D>(
6773 self.csrk.as_ref().map(<PeerKey as fidl::encoding::ValueTypeMarker>::borrow),
6774 encoder,
6775 offset + cur_offset,
6776 depth,
6777 )?;
6778
6779 _prev_end_offset = cur_offset + envelope_size;
6780 if 5 > max_ordinal {
6781 return Ok(());
6782 }
6783
6784 let cur_offset: usize = (5 - 1) * envelope_size;
6787
6788 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6790
6791 fidl::encoding::encode_in_envelope_optional::<Ltk, D>(
6796 self.peer_ltk.as_ref().map(<Ltk as fidl::encoding::ValueTypeMarker>::borrow),
6797 encoder,
6798 offset + cur_offset,
6799 depth,
6800 )?;
6801
6802 _prev_end_offset = cur_offset + envelope_size;
6803 if 6 > max_ordinal {
6804 return Ok(());
6805 }
6806
6807 let cur_offset: usize = (6 - 1) * envelope_size;
6810
6811 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6813
6814 fidl::encoding::encode_in_envelope_optional::<Ltk, D>(
6819 self.local_ltk.as_ref().map(<Ltk as fidl::encoding::ValueTypeMarker>::borrow),
6820 encoder,
6821 offset + cur_offset,
6822 depth,
6823 )?;
6824
6825 _prev_end_offset = cur_offset + envelope_size;
6826
6827 Ok(())
6828 }
6829 }
6830
6831 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeBondData {
6832 #[inline(always)]
6833 fn new_empty() -> Self {
6834 Self::default()
6835 }
6836
6837 unsafe fn decode(
6838 &mut self,
6839 decoder: &mut fidl::encoding::Decoder<'_, D>,
6840 offset: usize,
6841 mut depth: fidl::encoding::Depth,
6842 ) -> fidl::Result<()> {
6843 decoder.debug_check_bounds::<Self>(offset);
6844 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6845 None => return Err(fidl::Error::NotNullable),
6846 Some(len) => len,
6847 };
6848 if len == 0 {
6850 return Ok(());
6851 };
6852 depth.increment()?;
6853 let envelope_size = 8;
6854 let bytes_len = len * envelope_size;
6855 let offset = decoder.out_of_line_offset(bytes_len)?;
6856 let mut _next_ordinal_to_read = 0;
6858 let mut next_offset = offset;
6859 let end_offset = offset + bytes_len;
6860 _next_ordinal_to_read += 1;
6861 if next_offset >= end_offset {
6862 return Ok(());
6863 }
6864
6865 while _next_ordinal_to_read < 1 {
6867 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6868 _next_ordinal_to_read += 1;
6869 next_offset += envelope_size;
6870 }
6871
6872 let next_out_of_line = decoder.next_out_of_line();
6873 let handles_before = decoder.remaining_handles();
6874 if let Some((inlined, num_bytes, num_handles)) =
6875 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6876 {
6877 let member_inline_size =
6878 <LeConnectionParameters as fidl::encoding::TypeMarker>::inline_size(
6879 decoder.context,
6880 );
6881 if inlined != (member_inline_size <= 4) {
6882 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6883 }
6884 let inner_offset;
6885 let mut inner_depth = depth.clone();
6886 if inlined {
6887 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6888 inner_offset = next_offset;
6889 } else {
6890 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6891 inner_depth.increment()?;
6892 }
6893 let val_ref = self
6894 .connection_parameters
6895 .get_or_insert_with(|| fidl::new_empty!(LeConnectionParameters, D));
6896 fidl::decode!(
6897 LeConnectionParameters,
6898 D,
6899 val_ref,
6900 decoder,
6901 inner_offset,
6902 inner_depth
6903 )?;
6904 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6905 {
6906 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6907 }
6908 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6909 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6910 }
6911 }
6912
6913 next_offset += envelope_size;
6914 _next_ordinal_to_read += 1;
6915 if next_offset >= end_offset {
6916 return Ok(());
6917 }
6918
6919 while _next_ordinal_to_read < 2 {
6921 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6922 _next_ordinal_to_read += 1;
6923 next_offset += envelope_size;
6924 }
6925
6926 let next_out_of_line = decoder.next_out_of_line();
6927 let handles_before = decoder.remaining_handles();
6928 if let Some((inlined, num_bytes, num_handles)) =
6929 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6930 {
6931 let member_inline_size = <fidl::encoding::Vector<
6932 fidl_fuchsia_bluetooth__common::Uuid,
6933 65535,
6934 > as fidl::encoding::TypeMarker>::inline_size(
6935 decoder.context
6936 );
6937 if inlined != (member_inline_size <= 4) {
6938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6939 }
6940 let inner_offset;
6941 let mut inner_depth = depth.clone();
6942 if inlined {
6943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6944 inner_offset = next_offset;
6945 } else {
6946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6947 inner_depth.increment()?;
6948 }
6949 let val_ref =
6950 self.services.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D));
6951 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D, val_ref, decoder, inner_offset, inner_depth)?;
6952 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6953 {
6954 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6955 }
6956 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6957 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6958 }
6959 }
6960
6961 next_offset += envelope_size;
6962 _next_ordinal_to_read += 1;
6963 if next_offset >= end_offset {
6964 return Ok(());
6965 }
6966
6967 while _next_ordinal_to_read < 3 {
6969 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6970 _next_ordinal_to_read += 1;
6971 next_offset += envelope_size;
6972 }
6973
6974 let next_out_of_line = decoder.next_out_of_line();
6975 let handles_before = decoder.remaining_handles();
6976 if let Some((inlined, num_bytes, num_handles)) =
6977 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6978 {
6979 let member_inline_size =
6980 <PeerKey as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6981 if inlined != (member_inline_size <= 4) {
6982 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6983 }
6984 let inner_offset;
6985 let mut inner_depth = depth.clone();
6986 if inlined {
6987 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6988 inner_offset = next_offset;
6989 } else {
6990 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6991 inner_depth.increment()?;
6992 }
6993 let val_ref = self.irk.get_or_insert_with(|| fidl::new_empty!(PeerKey, D));
6994 fidl::decode!(PeerKey, D, val_ref, decoder, inner_offset, inner_depth)?;
6995 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6996 {
6997 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6998 }
6999 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7000 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7001 }
7002 }
7003
7004 next_offset += envelope_size;
7005 _next_ordinal_to_read += 1;
7006 if next_offset >= end_offset {
7007 return Ok(());
7008 }
7009
7010 while _next_ordinal_to_read < 4 {
7012 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7013 _next_ordinal_to_read += 1;
7014 next_offset += envelope_size;
7015 }
7016
7017 let next_out_of_line = decoder.next_out_of_line();
7018 let handles_before = decoder.remaining_handles();
7019 if let Some((inlined, num_bytes, num_handles)) =
7020 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7021 {
7022 let member_inline_size =
7023 <PeerKey as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7024 if inlined != (member_inline_size <= 4) {
7025 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7026 }
7027 let inner_offset;
7028 let mut inner_depth = depth.clone();
7029 if inlined {
7030 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7031 inner_offset = next_offset;
7032 } else {
7033 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7034 inner_depth.increment()?;
7035 }
7036 let val_ref = self.csrk.get_or_insert_with(|| fidl::new_empty!(PeerKey, D));
7037 fidl::decode!(PeerKey, D, val_ref, decoder, inner_offset, inner_depth)?;
7038 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7039 {
7040 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7041 }
7042 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7043 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7044 }
7045 }
7046
7047 next_offset += envelope_size;
7048 _next_ordinal_to_read += 1;
7049 if next_offset >= end_offset {
7050 return Ok(());
7051 }
7052
7053 while _next_ordinal_to_read < 5 {
7055 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7056 _next_ordinal_to_read += 1;
7057 next_offset += envelope_size;
7058 }
7059
7060 let next_out_of_line = decoder.next_out_of_line();
7061 let handles_before = decoder.remaining_handles();
7062 if let Some((inlined, num_bytes, num_handles)) =
7063 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7064 {
7065 let member_inline_size =
7066 <Ltk as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7067 if inlined != (member_inline_size <= 4) {
7068 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7069 }
7070 let inner_offset;
7071 let mut inner_depth = depth.clone();
7072 if inlined {
7073 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7074 inner_offset = next_offset;
7075 } else {
7076 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7077 inner_depth.increment()?;
7078 }
7079 let val_ref = self.peer_ltk.get_or_insert_with(|| fidl::new_empty!(Ltk, D));
7080 fidl::decode!(Ltk, D, val_ref, decoder, inner_offset, inner_depth)?;
7081 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7082 {
7083 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7084 }
7085 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7086 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7087 }
7088 }
7089
7090 next_offset += envelope_size;
7091 _next_ordinal_to_read += 1;
7092 if next_offset >= end_offset {
7093 return Ok(());
7094 }
7095
7096 while _next_ordinal_to_read < 6 {
7098 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7099 _next_ordinal_to_read += 1;
7100 next_offset += envelope_size;
7101 }
7102
7103 let next_out_of_line = decoder.next_out_of_line();
7104 let handles_before = decoder.remaining_handles();
7105 if let Some((inlined, num_bytes, num_handles)) =
7106 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7107 {
7108 let member_inline_size =
7109 <Ltk as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7110 if inlined != (member_inline_size <= 4) {
7111 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7112 }
7113 let inner_offset;
7114 let mut inner_depth = depth.clone();
7115 if inlined {
7116 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7117 inner_offset = next_offset;
7118 } else {
7119 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7120 inner_depth.increment()?;
7121 }
7122 let val_ref = self.local_ltk.get_or_insert_with(|| fidl::new_empty!(Ltk, D));
7123 fidl::decode!(Ltk, D, val_ref, decoder, inner_offset, inner_depth)?;
7124 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7125 {
7126 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7127 }
7128 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7129 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7130 }
7131 }
7132
7133 next_offset += envelope_size;
7134
7135 while next_offset < end_offset {
7137 _next_ordinal_to_read += 1;
7138 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7139 next_offset += envelope_size;
7140 }
7141
7142 Ok(())
7143 }
7144 }
7145
7146 impl PairingOptions {
7147 #[inline(always)]
7148 fn max_ordinal_present(&self) -> u64 {
7149 if let Some(_) = self.transport {
7150 return 3;
7151 }
7152 if let Some(_) = self.bondable_mode {
7153 return 2;
7154 }
7155 if let Some(_) = self.le_security_level {
7156 return 1;
7157 }
7158 0
7159 }
7160 }
7161
7162 impl fidl::encoding::ValueTypeMarker for PairingOptions {
7163 type Borrowed<'a> = &'a Self;
7164 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7165 value
7166 }
7167 }
7168
7169 unsafe impl fidl::encoding::TypeMarker for PairingOptions {
7170 type Owned = Self;
7171
7172 #[inline(always)]
7173 fn inline_align(_context: fidl::encoding::Context) -> usize {
7174 8
7175 }
7176
7177 #[inline(always)]
7178 fn inline_size(_context: fidl::encoding::Context) -> usize {
7179 16
7180 }
7181 }
7182
7183 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PairingOptions, D>
7184 for &PairingOptions
7185 {
7186 unsafe fn encode(
7187 self,
7188 encoder: &mut fidl::encoding::Encoder<'_, D>,
7189 offset: usize,
7190 mut depth: fidl::encoding::Depth,
7191 ) -> fidl::Result<()> {
7192 encoder.debug_check_bounds::<PairingOptions>(offset);
7193 let max_ordinal: u64 = self.max_ordinal_present();
7195 encoder.write_num(max_ordinal, offset);
7196 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7197 if max_ordinal == 0 {
7199 return Ok(());
7200 }
7201 depth.increment()?;
7202 let envelope_size = 8;
7203 let bytes_len = max_ordinal as usize * envelope_size;
7204 #[allow(unused_variables)]
7205 let offset = encoder.out_of_line_offset(bytes_len);
7206 let mut _prev_end_offset: usize = 0;
7207 if 1 > max_ordinal {
7208 return Ok(());
7209 }
7210
7211 let cur_offset: usize = (1 - 1) * envelope_size;
7214
7215 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7217
7218 fidl::encoding::encode_in_envelope_optional::<PairingSecurityLevel, D>(
7223 self.le_security_level
7224 .as_ref()
7225 .map(<PairingSecurityLevel as fidl::encoding::ValueTypeMarker>::borrow),
7226 encoder,
7227 offset + cur_offset,
7228 depth,
7229 )?;
7230
7231 _prev_end_offset = cur_offset + envelope_size;
7232 if 2 > max_ordinal {
7233 return Ok(());
7234 }
7235
7236 let cur_offset: usize = (2 - 1) * envelope_size;
7239
7240 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7242
7243 fidl::encoding::encode_in_envelope_optional::<BondableMode, D>(
7248 self.bondable_mode
7249 .as_ref()
7250 .map(<BondableMode as fidl::encoding::ValueTypeMarker>::borrow),
7251 encoder,
7252 offset + cur_offset,
7253 depth,
7254 )?;
7255
7256 _prev_end_offset = cur_offset + envelope_size;
7257 if 3 > max_ordinal {
7258 return Ok(());
7259 }
7260
7261 let cur_offset: usize = (3 - 1) * envelope_size;
7264
7265 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7267
7268 fidl::encoding::encode_in_envelope_optional::<TechnologyType, D>(
7273 self.transport
7274 .as_ref()
7275 .map(<TechnologyType as fidl::encoding::ValueTypeMarker>::borrow),
7276 encoder,
7277 offset + cur_offset,
7278 depth,
7279 )?;
7280
7281 _prev_end_offset = cur_offset + envelope_size;
7282
7283 Ok(())
7284 }
7285 }
7286
7287 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PairingOptions {
7288 #[inline(always)]
7289 fn new_empty() -> Self {
7290 Self::default()
7291 }
7292
7293 unsafe fn decode(
7294 &mut self,
7295 decoder: &mut fidl::encoding::Decoder<'_, D>,
7296 offset: usize,
7297 mut depth: fidl::encoding::Depth,
7298 ) -> fidl::Result<()> {
7299 decoder.debug_check_bounds::<Self>(offset);
7300 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7301 None => return Err(fidl::Error::NotNullable),
7302 Some(len) => len,
7303 };
7304 if len == 0 {
7306 return Ok(());
7307 };
7308 depth.increment()?;
7309 let envelope_size = 8;
7310 let bytes_len = len * envelope_size;
7311 let offset = decoder.out_of_line_offset(bytes_len)?;
7312 let mut _next_ordinal_to_read = 0;
7314 let mut next_offset = offset;
7315 let end_offset = offset + bytes_len;
7316 _next_ordinal_to_read += 1;
7317 if next_offset >= end_offset {
7318 return Ok(());
7319 }
7320
7321 while _next_ordinal_to_read < 1 {
7323 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7324 _next_ordinal_to_read += 1;
7325 next_offset += envelope_size;
7326 }
7327
7328 let next_out_of_line = decoder.next_out_of_line();
7329 let handles_before = decoder.remaining_handles();
7330 if let Some((inlined, num_bytes, num_handles)) =
7331 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7332 {
7333 let member_inline_size =
7334 <PairingSecurityLevel as fidl::encoding::TypeMarker>::inline_size(
7335 decoder.context,
7336 );
7337 if inlined != (member_inline_size <= 4) {
7338 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7339 }
7340 let inner_offset;
7341 let mut inner_depth = depth.clone();
7342 if inlined {
7343 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7344 inner_offset = next_offset;
7345 } else {
7346 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7347 inner_depth.increment()?;
7348 }
7349 let val_ref = self
7350 .le_security_level
7351 .get_or_insert_with(|| fidl::new_empty!(PairingSecurityLevel, D));
7352 fidl::decode!(
7353 PairingSecurityLevel,
7354 D,
7355 val_ref,
7356 decoder,
7357 inner_offset,
7358 inner_depth
7359 )?;
7360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7361 {
7362 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7363 }
7364 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7365 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7366 }
7367 }
7368
7369 next_offset += envelope_size;
7370 _next_ordinal_to_read += 1;
7371 if next_offset >= end_offset {
7372 return Ok(());
7373 }
7374
7375 while _next_ordinal_to_read < 2 {
7377 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7378 _next_ordinal_to_read += 1;
7379 next_offset += envelope_size;
7380 }
7381
7382 let next_out_of_line = decoder.next_out_of_line();
7383 let handles_before = decoder.remaining_handles();
7384 if let Some((inlined, num_bytes, num_handles)) =
7385 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7386 {
7387 let member_inline_size =
7388 <BondableMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7389 if inlined != (member_inline_size <= 4) {
7390 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7391 }
7392 let inner_offset;
7393 let mut inner_depth = depth.clone();
7394 if inlined {
7395 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7396 inner_offset = next_offset;
7397 } else {
7398 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7399 inner_depth.increment()?;
7400 }
7401 let val_ref =
7402 self.bondable_mode.get_or_insert_with(|| fidl::new_empty!(BondableMode, D));
7403 fidl::decode!(BondableMode, D, val_ref, decoder, inner_offset, inner_depth)?;
7404 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7405 {
7406 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7407 }
7408 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7409 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7410 }
7411 }
7412
7413 next_offset += envelope_size;
7414 _next_ordinal_to_read += 1;
7415 if next_offset >= end_offset {
7416 return Ok(());
7417 }
7418
7419 while _next_ordinal_to_read < 3 {
7421 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7422 _next_ordinal_to_read += 1;
7423 next_offset += envelope_size;
7424 }
7425
7426 let next_out_of_line = decoder.next_out_of_line();
7427 let handles_before = decoder.remaining_handles();
7428 if let Some((inlined, num_bytes, num_handles)) =
7429 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7430 {
7431 let member_inline_size =
7432 <TechnologyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7433 if inlined != (member_inline_size <= 4) {
7434 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7435 }
7436 let inner_offset;
7437 let mut inner_depth = depth.clone();
7438 if inlined {
7439 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7440 inner_offset = next_offset;
7441 } else {
7442 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7443 inner_depth.increment()?;
7444 }
7445 let val_ref =
7446 self.transport.get_or_insert_with(|| fidl::new_empty!(TechnologyType, D));
7447 fidl::decode!(TechnologyType, D, val_ref, decoder, inner_offset, inner_depth)?;
7448 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7449 {
7450 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7451 }
7452 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7453 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7454 }
7455 }
7456
7457 next_offset += envelope_size;
7458
7459 while next_offset < end_offset {
7461 _next_ordinal_to_read += 1;
7462 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7463 next_offset += envelope_size;
7464 }
7465
7466 Ok(())
7467 }
7468 }
7469
7470 impl PairingRequestAcceptRequest {
7471 #[inline(always)]
7472 fn max_ordinal_present(&self) -> u64 {
7473 if let Some(_) = self.entered_passkey {
7474 return 1;
7475 }
7476 0
7477 }
7478 }
7479
7480 impl fidl::encoding::ValueTypeMarker for PairingRequestAcceptRequest {
7481 type Borrowed<'a> = &'a Self;
7482 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7483 value
7484 }
7485 }
7486
7487 unsafe impl fidl::encoding::TypeMarker for PairingRequestAcceptRequest {
7488 type Owned = Self;
7489
7490 #[inline(always)]
7491 fn inline_align(_context: fidl::encoding::Context) -> usize {
7492 8
7493 }
7494
7495 #[inline(always)]
7496 fn inline_size(_context: fidl::encoding::Context) -> usize {
7497 16
7498 }
7499 }
7500
7501 unsafe impl<D: fidl::encoding::ResourceDialect>
7502 fidl::encoding::Encode<PairingRequestAcceptRequest, D> for &PairingRequestAcceptRequest
7503 {
7504 unsafe fn encode(
7505 self,
7506 encoder: &mut fidl::encoding::Encoder<'_, D>,
7507 offset: usize,
7508 mut depth: fidl::encoding::Depth,
7509 ) -> fidl::Result<()> {
7510 encoder.debug_check_bounds::<PairingRequestAcceptRequest>(offset);
7511 let max_ordinal: u64 = self.max_ordinal_present();
7513 encoder.write_num(max_ordinal, offset);
7514 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7515 if max_ordinal == 0 {
7517 return Ok(());
7518 }
7519 depth.increment()?;
7520 let envelope_size = 8;
7521 let bytes_len = max_ordinal as usize * envelope_size;
7522 #[allow(unused_variables)]
7523 let offset = encoder.out_of_line_offset(bytes_len);
7524 let mut _prev_end_offset: usize = 0;
7525 if 1 > max_ordinal {
7526 return Ok(());
7527 }
7528
7529 let cur_offset: usize = (1 - 1) * envelope_size;
7532
7533 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7535
7536 fidl::encoding::encode_in_envelope_optional::<u32, D>(
7541 self.entered_passkey.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7542 encoder,
7543 offset + cur_offset,
7544 depth,
7545 )?;
7546
7547 _prev_end_offset = cur_offset + envelope_size;
7548
7549 Ok(())
7550 }
7551 }
7552
7553 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7554 for PairingRequestAcceptRequest
7555 {
7556 #[inline(always)]
7557 fn new_empty() -> Self {
7558 Self::default()
7559 }
7560
7561 unsafe fn decode(
7562 &mut self,
7563 decoder: &mut fidl::encoding::Decoder<'_, D>,
7564 offset: usize,
7565 mut depth: fidl::encoding::Depth,
7566 ) -> fidl::Result<()> {
7567 decoder.debug_check_bounds::<Self>(offset);
7568 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7569 None => return Err(fidl::Error::NotNullable),
7570 Some(len) => len,
7571 };
7572 if len == 0 {
7574 return Ok(());
7575 };
7576 depth.increment()?;
7577 let envelope_size = 8;
7578 let bytes_len = len * envelope_size;
7579 let offset = decoder.out_of_line_offset(bytes_len)?;
7580 let mut _next_ordinal_to_read = 0;
7582 let mut next_offset = offset;
7583 let end_offset = offset + bytes_len;
7584 _next_ordinal_to_read += 1;
7585 if next_offset >= end_offset {
7586 return Ok(());
7587 }
7588
7589 while _next_ordinal_to_read < 1 {
7591 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7592 _next_ordinal_to_read += 1;
7593 next_offset += envelope_size;
7594 }
7595
7596 let next_out_of_line = decoder.next_out_of_line();
7597 let handles_before = decoder.remaining_handles();
7598 if let Some((inlined, num_bytes, num_handles)) =
7599 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7600 {
7601 let member_inline_size =
7602 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7603 if inlined != (member_inline_size <= 4) {
7604 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7605 }
7606 let inner_offset;
7607 let mut inner_depth = depth.clone();
7608 if inlined {
7609 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7610 inner_offset = next_offset;
7611 } else {
7612 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7613 inner_depth.increment()?;
7614 }
7615 let val_ref = self.entered_passkey.get_or_insert_with(|| fidl::new_empty!(u32, D));
7616 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7617 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7618 {
7619 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7620 }
7621 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7622 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7623 }
7624 }
7625
7626 next_offset += envelope_size;
7627
7628 while next_offset < end_offset {
7630 _next_ordinal_to_read += 1;
7631 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7632 next_offset += envelope_size;
7633 }
7634
7635 Ok(())
7636 }
7637 }
7638
7639 impl Peer {
7640 #[inline(always)]
7641 fn max_ordinal_present(&self) -> u64 {
7642 if let Some(_) = self.bredr_services {
7643 return 13;
7644 }
7645 if let Some(_) = self.le_services {
7646 return 12;
7647 }
7648 if let Some(_) = self.services {
7649 return 11;
7650 }
7651 if let Some(_) = self.tx_power {
7652 return 10;
7653 }
7654 if let Some(_) = self.rssi {
7655 return 9;
7656 }
7657 if let Some(_) = self.device_class {
7658 return 8;
7659 }
7660 if let Some(_) = self.appearance {
7661 return 7;
7662 }
7663 if let Some(_) = self.name {
7664 return 6;
7665 }
7666 if let Some(_) = self.bonded {
7667 return 5;
7668 }
7669 if let Some(_) = self.connected {
7670 return 4;
7671 }
7672 if let Some(_) = self.technology {
7673 return 3;
7674 }
7675 if let Some(_) = self.address {
7676 return 2;
7677 }
7678 if let Some(_) = self.id {
7679 return 1;
7680 }
7681 0
7682 }
7683 }
7684
7685 impl fidl::encoding::ValueTypeMarker for Peer {
7686 type Borrowed<'a> = &'a Self;
7687 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7688 value
7689 }
7690 }
7691
7692 unsafe impl fidl::encoding::TypeMarker for Peer {
7693 type Owned = Self;
7694
7695 #[inline(always)]
7696 fn inline_align(_context: fidl::encoding::Context) -> usize {
7697 8
7698 }
7699
7700 #[inline(always)]
7701 fn inline_size(_context: fidl::encoding::Context) -> usize {
7702 16
7703 }
7704 }
7705
7706 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Peer, D> for &Peer {
7707 unsafe fn encode(
7708 self,
7709 encoder: &mut fidl::encoding::Encoder<'_, D>,
7710 offset: usize,
7711 mut depth: fidl::encoding::Depth,
7712 ) -> fidl::Result<()> {
7713 encoder.debug_check_bounds::<Peer>(offset);
7714 let max_ordinal: u64 = self.max_ordinal_present();
7716 encoder.write_num(max_ordinal, offset);
7717 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7718 if max_ordinal == 0 {
7720 return Ok(());
7721 }
7722 depth.increment()?;
7723 let envelope_size = 8;
7724 let bytes_len = max_ordinal as usize * envelope_size;
7725 #[allow(unused_variables)]
7726 let offset = encoder.out_of_line_offset(bytes_len);
7727 let mut _prev_end_offset: usize = 0;
7728 if 1 > max_ordinal {
7729 return Ok(());
7730 }
7731
7732 let cur_offset: usize = (1 - 1) * envelope_size;
7735
7736 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7738
7739 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
7744 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
7745 encoder, offset + cur_offset, depth
7746 )?;
7747
7748 _prev_end_offset = cur_offset + envelope_size;
7749 if 2 > max_ordinal {
7750 return Ok(());
7751 }
7752
7753 let cur_offset: usize = (2 - 1) * envelope_size;
7756
7757 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7759
7760 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Address, D>(
7765 self.address.as_ref().map(<fidl_fuchsia_bluetooth__common::Address as fidl::encoding::ValueTypeMarker>::borrow),
7766 encoder, offset + cur_offset, depth
7767 )?;
7768
7769 _prev_end_offset = cur_offset + envelope_size;
7770 if 3 > max_ordinal {
7771 return Ok(());
7772 }
7773
7774 let cur_offset: usize = (3 - 1) * envelope_size;
7777
7778 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7780
7781 fidl::encoding::encode_in_envelope_optional::<TechnologyType, D>(
7786 self.technology
7787 .as_ref()
7788 .map(<TechnologyType as fidl::encoding::ValueTypeMarker>::borrow),
7789 encoder,
7790 offset + cur_offset,
7791 depth,
7792 )?;
7793
7794 _prev_end_offset = cur_offset + envelope_size;
7795 if 4 > max_ordinal {
7796 return Ok(());
7797 }
7798
7799 let cur_offset: usize = (4 - 1) * envelope_size;
7802
7803 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7805
7806 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7811 self.connected.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7812 encoder,
7813 offset + cur_offset,
7814 depth,
7815 )?;
7816
7817 _prev_end_offset = cur_offset + envelope_size;
7818 if 5 > max_ordinal {
7819 return Ok(());
7820 }
7821
7822 let cur_offset: usize = (5 - 1) * envelope_size;
7825
7826 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7828
7829 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7834 self.bonded.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7835 encoder,
7836 offset + cur_offset,
7837 depth,
7838 )?;
7839
7840 _prev_end_offset = cur_offset + envelope_size;
7841 if 6 > max_ordinal {
7842 return Ok(());
7843 }
7844
7845 let cur_offset: usize = (6 - 1) * envelope_size;
7848
7849 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7851
7852 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
7857 self.name.as_ref().map(
7858 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
7859 ),
7860 encoder,
7861 offset + cur_offset,
7862 depth,
7863 )?;
7864
7865 _prev_end_offset = cur_offset + envelope_size;
7866 if 7 > max_ordinal {
7867 return Ok(());
7868 }
7869
7870 let cur_offset: usize = (7 - 1) * envelope_size;
7873
7874 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7876
7877 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
7882 self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
7883 encoder, offset + cur_offset, depth
7884 )?;
7885
7886 _prev_end_offset = cur_offset + envelope_size;
7887 if 8 > max_ordinal {
7888 return Ok(());
7889 }
7890
7891 let cur_offset: usize = (8 - 1) * envelope_size;
7894
7895 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7897
7898 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DeviceClass, D>(
7903 self.device_class.as_ref().map(<fidl_fuchsia_bluetooth__common::DeviceClass as fidl::encoding::ValueTypeMarker>::borrow),
7904 encoder, offset + cur_offset, depth
7905 )?;
7906
7907 _prev_end_offset = cur_offset + envelope_size;
7908 if 9 > max_ordinal {
7909 return Ok(());
7910 }
7911
7912 let cur_offset: usize = (9 - 1) * envelope_size;
7915
7916 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7918
7919 fidl::encoding::encode_in_envelope_optional::<i8, D>(
7924 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7925 encoder,
7926 offset + cur_offset,
7927 depth,
7928 )?;
7929
7930 _prev_end_offset = cur_offset + envelope_size;
7931 if 10 > max_ordinal {
7932 return Ok(());
7933 }
7934
7935 let cur_offset: usize = (10 - 1) * envelope_size;
7938
7939 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7941
7942 fidl::encoding::encode_in_envelope_optional::<i8, D>(
7947 self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7948 encoder,
7949 offset + cur_offset,
7950 depth,
7951 )?;
7952
7953 _prev_end_offset = cur_offset + envelope_size;
7954 if 11 > max_ordinal {
7955 return Ok(());
7956 }
7957
7958 let cur_offset: usize = (11 - 1) * envelope_size;
7961
7962 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7964
7965 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D>(
7970 self.services.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535> as fidl::encoding::ValueTypeMarker>::borrow),
7971 encoder, offset + cur_offset, depth
7972 )?;
7973
7974 _prev_end_offset = cur_offset + envelope_size;
7975 if 12 > max_ordinal {
7976 return Ok(());
7977 }
7978
7979 let cur_offset: usize = (12 - 1) * envelope_size;
7982
7983 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7985
7986 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D>(
7991 self.le_services.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535> as fidl::encoding::ValueTypeMarker>::borrow),
7992 encoder, offset + cur_offset, depth
7993 )?;
7994
7995 _prev_end_offset = cur_offset + envelope_size;
7996 if 13 > max_ordinal {
7997 return Ok(());
7998 }
7999
8000 let cur_offset: usize = (13 - 1) * envelope_size;
8003
8004 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8006
8007 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D>(
8012 self.bredr_services.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535> as fidl::encoding::ValueTypeMarker>::borrow),
8013 encoder, offset + cur_offset, depth
8014 )?;
8015
8016 _prev_end_offset = cur_offset + envelope_size;
8017
8018 Ok(())
8019 }
8020 }
8021
8022 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Peer {
8023 #[inline(always)]
8024 fn new_empty() -> Self {
8025 Self::default()
8026 }
8027
8028 unsafe fn decode(
8029 &mut self,
8030 decoder: &mut fidl::encoding::Decoder<'_, D>,
8031 offset: usize,
8032 mut depth: fidl::encoding::Depth,
8033 ) -> fidl::Result<()> {
8034 decoder.debug_check_bounds::<Self>(offset);
8035 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8036 None => return Err(fidl::Error::NotNullable),
8037 Some(len) => len,
8038 };
8039 if len == 0 {
8041 return Ok(());
8042 };
8043 depth.increment()?;
8044 let envelope_size = 8;
8045 let bytes_len = len * envelope_size;
8046 let offset = decoder.out_of_line_offset(bytes_len)?;
8047 let mut _next_ordinal_to_read = 0;
8049 let mut next_offset = offset;
8050 let end_offset = offset + bytes_len;
8051 _next_ordinal_to_read += 1;
8052 if next_offset >= end_offset {
8053 return Ok(());
8054 }
8055
8056 while _next_ordinal_to_read < 1 {
8058 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8059 _next_ordinal_to_read += 1;
8060 next_offset += envelope_size;
8061 }
8062
8063 let next_out_of_line = decoder.next_out_of_line();
8064 let handles_before = decoder.remaining_handles();
8065 if let Some((inlined, num_bytes, num_handles)) =
8066 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8067 {
8068 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8069 if inlined != (member_inline_size <= 4) {
8070 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8071 }
8072 let inner_offset;
8073 let mut inner_depth = depth.clone();
8074 if inlined {
8075 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8076 inner_offset = next_offset;
8077 } else {
8078 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8079 inner_depth.increment()?;
8080 }
8081 let val_ref = self.id.get_or_insert_with(|| {
8082 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
8083 });
8084 fidl::decode!(
8085 fidl_fuchsia_bluetooth__common::PeerId,
8086 D,
8087 val_ref,
8088 decoder,
8089 inner_offset,
8090 inner_depth
8091 )?;
8092 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8093 {
8094 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8095 }
8096 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8097 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8098 }
8099 }
8100
8101 next_offset += envelope_size;
8102 _next_ordinal_to_read += 1;
8103 if next_offset >= end_offset {
8104 return Ok(());
8105 }
8106
8107 while _next_ordinal_to_read < 2 {
8109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8110 _next_ordinal_to_read += 1;
8111 next_offset += envelope_size;
8112 }
8113
8114 let next_out_of_line = decoder.next_out_of_line();
8115 let handles_before = decoder.remaining_handles();
8116 if let Some((inlined, num_bytes, num_handles)) =
8117 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8118 {
8119 let member_inline_size = <fidl_fuchsia_bluetooth__common::Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8120 if inlined != (member_inline_size <= 4) {
8121 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8122 }
8123 let inner_offset;
8124 let mut inner_depth = depth.clone();
8125 if inlined {
8126 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8127 inner_offset = next_offset;
8128 } else {
8129 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8130 inner_depth.increment()?;
8131 }
8132 let val_ref = self.address.get_or_insert_with(|| {
8133 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Address, D)
8134 });
8135 fidl::decode!(
8136 fidl_fuchsia_bluetooth__common::Address,
8137 D,
8138 val_ref,
8139 decoder,
8140 inner_offset,
8141 inner_depth
8142 )?;
8143 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8144 {
8145 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8146 }
8147 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8148 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8149 }
8150 }
8151
8152 next_offset += envelope_size;
8153 _next_ordinal_to_read += 1;
8154 if next_offset >= end_offset {
8155 return Ok(());
8156 }
8157
8158 while _next_ordinal_to_read < 3 {
8160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8161 _next_ordinal_to_read += 1;
8162 next_offset += envelope_size;
8163 }
8164
8165 let next_out_of_line = decoder.next_out_of_line();
8166 let handles_before = decoder.remaining_handles();
8167 if let Some((inlined, num_bytes, num_handles)) =
8168 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8169 {
8170 let member_inline_size =
8171 <TechnologyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8172 if inlined != (member_inline_size <= 4) {
8173 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8174 }
8175 let inner_offset;
8176 let mut inner_depth = depth.clone();
8177 if inlined {
8178 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8179 inner_offset = next_offset;
8180 } else {
8181 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8182 inner_depth.increment()?;
8183 }
8184 let val_ref =
8185 self.technology.get_or_insert_with(|| fidl::new_empty!(TechnologyType, D));
8186 fidl::decode!(TechnologyType, D, val_ref, decoder, inner_offset, inner_depth)?;
8187 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8188 {
8189 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8190 }
8191 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8192 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8193 }
8194 }
8195
8196 next_offset += envelope_size;
8197 _next_ordinal_to_read += 1;
8198 if next_offset >= end_offset {
8199 return Ok(());
8200 }
8201
8202 while _next_ordinal_to_read < 4 {
8204 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8205 _next_ordinal_to_read += 1;
8206 next_offset += envelope_size;
8207 }
8208
8209 let next_out_of_line = decoder.next_out_of_line();
8210 let handles_before = decoder.remaining_handles();
8211 if let Some((inlined, num_bytes, num_handles)) =
8212 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8213 {
8214 let member_inline_size =
8215 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8216 if inlined != (member_inline_size <= 4) {
8217 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8218 }
8219 let inner_offset;
8220 let mut inner_depth = depth.clone();
8221 if inlined {
8222 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8223 inner_offset = next_offset;
8224 } else {
8225 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8226 inner_depth.increment()?;
8227 }
8228 let val_ref = self.connected.get_or_insert_with(|| fidl::new_empty!(bool, D));
8229 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8230 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8231 {
8232 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8233 }
8234 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8235 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8236 }
8237 }
8238
8239 next_offset += envelope_size;
8240 _next_ordinal_to_read += 1;
8241 if next_offset >= end_offset {
8242 return Ok(());
8243 }
8244
8245 while _next_ordinal_to_read < 5 {
8247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8248 _next_ordinal_to_read += 1;
8249 next_offset += envelope_size;
8250 }
8251
8252 let next_out_of_line = decoder.next_out_of_line();
8253 let handles_before = decoder.remaining_handles();
8254 if let Some((inlined, num_bytes, num_handles)) =
8255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8256 {
8257 let member_inline_size =
8258 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8259 if inlined != (member_inline_size <= 4) {
8260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8261 }
8262 let inner_offset;
8263 let mut inner_depth = depth.clone();
8264 if inlined {
8265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8266 inner_offset = next_offset;
8267 } else {
8268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8269 inner_depth.increment()?;
8270 }
8271 let val_ref = self.bonded.get_or_insert_with(|| fidl::new_empty!(bool, D));
8272 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8274 {
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 }
8281
8282 next_offset += envelope_size;
8283 _next_ordinal_to_read += 1;
8284 if next_offset >= end_offset {
8285 return Ok(());
8286 }
8287
8288 while _next_ordinal_to_read < 6 {
8290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8291 _next_ordinal_to_read += 1;
8292 next_offset += envelope_size;
8293 }
8294
8295 let next_out_of_line = decoder.next_out_of_line();
8296 let handles_before = decoder.remaining_handles();
8297 if let Some((inlined, num_bytes, num_handles)) =
8298 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8299 {
8300 let member_inline_size =
8301 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
8302 decoder.context,
8303 );
8304 if inlined != (member_inline_size <= 4) {
8305 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8306 }
8307 let inner_offset;
8308 let mut inner_depth = depth.clone();
8309 if inlined {
8310 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8311 inner_offset = next_offset;
8312 } else {
8313 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8314 inner_depth.increment()?;
8315 }
8316 let val_ref = self
8317 .name
8318 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
8319 fidl::decode!(
8320 fidl::encoding::BoundedString<248>,
8321 D,
8322 val_ref,
8323 decoder,
8324 inner_offset,
8325 inner_depth
8326 )?;
8327 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8328 {
8329 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8330 }
8331 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8332 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8333 }
8334 }
8335
8336 next_offset += envelope_size;
8337 _next_ordinal_to_read += 1;
8338 if next_offset >= end_offset {
8339 return Ok(());
8340 }
8341
8342 while _next_ordinal_to_read < 7 {
8344 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8345 _next_ordinal_to_read += 1;
8346 next_offset += envelope_size;
8347 }
8348
8349 let next_out_of_line = decoder.next_out_of_line();
8350 let handles_before = decoder.remaining_handles();
8351 if let Some((inlined, num_bytes, num_handles)) =
8352 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8353 {
8354 let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8355 if inlined != (member_inline_size <= 4) {
8356 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8357 }
8358 let inner_offset;
8359 let mut inner_depth = depth.clone();
8360 if inlined {
8361 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8362 inner_offset = next_offset;
8363 } else {
8364 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8365 inner_depth.increment()?;
8366 }
8367 let val_ref = self.appearance.get_or_insert_with(|| {
8368 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
8369 });
8370 fidl::decode!(
8371 fidl_fuchsia_bluetooth__common::Appearance,
8372 D,
8373 val_ref,
8374 decoder,
8375 inner_offset,
8376 inner_depth
8377 )?;
8378 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8379 {
8380 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8381 }
8382 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8383 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8384 }
8385 }
8386
8387 next_offset += envelope_size;
8388 _next_ordinal_to_read += 1;
8389 if next_offset >= end_offset {
8390 return Ok(());
8391 }
8392
8393 while _next_ordinal_to_read < 8 {
8395 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8396 _next_ordinal_to_read += 1;
8397 next_offset += envelope_size;
8398 }
8399
8400 let next_out_of_line = decoder.next_out_of_line();
8401 let handles_before = decoder.remaining_handles();
8402 if let Some((inlined, num_bytes, num_handles)) =
8403 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8404 {
8405 let member_inline_size = <fidl_fuchsia_bluetooth__common::DeviceClass as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8406 if inlined != (member_inline_size <= 4) {
8407 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8408 }
8409 let inner_offset;
8410 let mut inner_depth = depth.clone();
8411 if inlined {
8412 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8413 inner_offset = next_offset;
8414 } else {
8415 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8416 inner_depth.increment()?;
8417 }
8418 let val_ref = self.device_class.get_or_insert_with(|| {
8419 fidl::new_empty!(fidl_fuchsia_bluetooth__common::DeviceClass, D)
8420 });
8421 fidl::decode!(
8422 fidl_fuchsia_bluetooth__common::DeviceClass,
8423 D,
8424 val_ref,
8425 decoder,
8426 inner_offset,
8427 inner_depth
8428 )?;
8429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8430 {
8431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8432 }
8433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8435 }
8436 }
8437
8438 next_offset += envelope_size;
8439 _next_ordinal_to_read += 1;
8440 if next_offset >= end_offset {
8441 return Ok(());
8442 }
8443
8444 while _next_ordinal_to_read < 9 {
8446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8447 _next_ordinal_to_read += 1;
8448 next_offset += envelope_size;
8449 }
8450
8451 let next_out_of_line = decoder.next_out_of_line();
8452 let handles_before = decoder.remaining_handles();
8453 if let Some((inlined, num_bytes, num_handles)) =
8454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8455 {
8456 let member_inline_size =
8457 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8458 if inlined != (member_inline_size <= 4) {
8459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8460 }
8461 let inner_offset;
8462 let mut inner_depth = depth.clone();
8463 if inlined {
8464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8465 inner_offset = next_offset;
8466 } else {
8467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8468 inner_depth.increment()?;
8469 }
8470 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
8471 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
8472 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8473 {
8474 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8475 }
8476 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8477 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8478 }
8479 }
8480
8481 next_offset += envelope_size;
8482 _next_ordinal_to_read += 1;
8483 if next_offset >= end_offset {
8484 return Ok(());
8485 }
8486
8487 while _next_ordinal_to_read < 10 {
8489 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8490 _next_ordinal_to_read += 1;
8491 next_offset += envelope_size;
8492 }
8493
8494 let next_out_of_line = decoder.next_out_of_line();
8495 let handles_before = decoder.remaining_handles();
8496 if let Some((inlined, num_bytes, num_handles)) =
8497 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8498 {
8499 let member_inline_size =
8500 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8501 if inlined != (member_inline_size <= 4) {
8502 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8503 }
8504 let inner_offset;
8505 let mut inner_depth = depth.clone();
8506 if inlined {
8507 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8508 inner_offset = next_offset;
8509 } else {
8510 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8511 inner_depth.increment()?;
8512 }
8513 let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
8514 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
8515 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8516 {
8517 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8518 }
8519 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8520 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8521 }
8522 }
8523
8524 next_offset += envelope_size;
8525 _next_ordinal_to_read += 1;
8526 if next_offset >= end_offset {
8527 return Ok(());
8528 }
8529
8530 while _next_ordinal_to_read < 11 {
8532 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8533 _next_ordinal_to_read += 1;
8534 next_offset += envelope_size;
8535 }
8536
8537 let next_out_of_line = decoder.next_out_of_line();
8538 let handles_before = decoder.remaining_handles();
8539 if let Some((inlined, num_bytes, num_handles)) =
8540 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8541 {
8542 let member_inline_size = <fidl::encoding::Vector<
8543 fidl_fuchsia_bluetooth__common::Uuid,
8544 65535,
8545 > as fidl::encoding::TypeMarker>::inline_size(
8546 decoder.context
8547 );
8548 if inlined != (member_inline_size <= 4) {
8549 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8550 }
8551 let inner_offset;
8552 let mut inner_depth = depth.clone();
8553 if inlined {
8554 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8555 inner_offset = next_offset;
8556 } else {
8557 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8558 inner_depth.increment()?;
8559 }
8560 let val_ref =
8561 self.services.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D));
8562 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D, val_ref, decoder, inner_offset, inner_depth)?;
8563 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8564 {
8565 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8566 }
8567 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8568 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8569 }
8570 }
8571
8572 next_offset += envelope_size;
8573 _next_ordinal_to_read += 1;
8574 if next_offset >= end_offset {
8575 return Ok(());
8576 }
8577
8578 while _next_ordinal_to_read < 12 {
8580 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8581 _next_ordinal_to_read += 1;
8582 next_offset += envelope_size;
8583 }
8584
8585 let next_out_of_line = decoder.next_out_of_line();
8586 let handles_before = decoder.remaining_handles();
8587 if let Some((inlined, num_bytes, num_handles)) =
8588 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8589 {
8590 let member_inline_size = <fidl::encoding::Vector<
8591 fidl_fuchsia_bluetooth__common::Uuid,
8592 65535,
8593 > as fidl::encoding::TypeMarker>::inline_size(
8594 decoder.context
8595 );
8596 if inlined != (member_inline_size <= 4) {
8597 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8598 }
8599 let inner_offset;
8600 let mut inner_depth = depth.clone();
8601 if inlined {
8602 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8603 inner_offset = next_offset;
8604 } else {
8605 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8606 inner_depth.increment()?;
8607 }
8608 let val_ref =
8609 self.le_services.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D));
8610 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D, val_ref, decoder, inner_offset, inner_depth)?;
8611 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8612 {
8613 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8614 }
8615 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8616 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8617 }
8618 }
8619
8620 next_offset += envelope_size;
8621 _next_ordinal_to_read += 1;
8622 if next_offset >= end_offset {
8623 return Ok(());
8624 }
8625
8626 while _next_ordinal_to_read < 13 {
8628 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8629 _next_ordinal_to_read += 1;
8630 next_offset += envelope_size;
8631 }
8632
8633 let next_out_of_line = decoder.next_out_of_line();
8634 let handles_before = decoder.remaining_handles();
8635 if let Some((inlined, num_bytes, num_handles)) =
8636 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8637 {
8638 let member_inline_size = <fidl::encoding::Vector<
8639 fidl_fuchsia_bluetooth__common::Uuid,
8640 65535,
8641 > as fidl::encoding::TypeMarker>::inline_size(
8642 decoder.context
8643 );
8644 if inlined != (member_inline_size <= 4) {
8645 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8646 }
8647 let inner_offset;
8648 let mut inner_depth = depth.clone();
8649 if inlined {
8650 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8651 inner_offset = next_offset;
8652 } else {
8653 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8654 inner_depth.increment()?;
8655 }
8656 let val_ref =
8657 self.bredr_services.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D));
8658 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_bluetooth__common::Uuid, 65535>, D, val_ref, decoder, inner_offset, inner_depth)?;
8659 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8660 {
8661 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8662 }
8663 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8664 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8665 }
8666 }
8667
8668 next_offset += envelope_size;
8669
8670 while next_offset < end_offset {
8672 _next_ordinal_to_read += 1;
8673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8674 next_offset += envelope_size;
8675 }
8676
8677 Ok(())
8678 }
8679 }
8680
8681 impl Settings {
8682 #[inline(always)]
8683 fn max_ordinal_present(&self) -> u64 {
8684 if let Some(_) = self.bredr_security_mode {
8685 return 5;
8686 }
8687 if let Some(_) = self.le_security_mode {
8688 return 4;
8689 }
8690 if let Some(_) = self.bredr_connectable_mode {
8691 return 3;
8692 }
8693 if let Some(_) = self.le_background_scan {
8694 return 2;
8695 }
8696 if let Some(_) = self.le_privacy {
8697 return 1;
8698 }
8699 0
8700 }
8701 }
8702
8703 impl fidl::encoding::ValueTypeMarker for Settings {
8704 type Borrowed<'a> = &'a Self;
8705 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8706 value
8707 }
8708 }
8709
8710 unsafe impl fidl::encoding::TypeMarker for Settings {
8711 type Owned = Self;
8712
8713 #[inline(always)]
8714 fn inline_align(_context: fidl::encoding::Context) -> usize {
8715 8
8716 }
8717
8718 #[inline(always)]
8719 fn inline_size(_context: fidl::encoding::Context) -> usize {
8720 16
8721 }
8722 }
8723
8724 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Settings, D> for &Settings {
8725 unsafe fn encode(
8726 self,
8727 encoder: &mut fidl::encoding::Encoder<'_, D>,
8728 offset: usize,
8729 mut depth: fidl::encoding::Depth,
8730 ) -> fidl::Result<()> {
8731 encoder.debug_check_bounds::<Settings>(offset);
8732 let max_ordinal: u64 = self.max_ordinal_present();
8734 encoder.write_num(max_ordinal, offset);
8735 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8736 if max_ordinal == 0 {
8738 return Ok(());
8739 }
8740 depth.increment()?;
8741 let envelope_size = 8;
8742 let bytes_len = max_ordinal as usize * envelope_size;
8743 #[allow(unused_variables)]
8744 let offset = encoder.out_of_line_offset(bytes_len);
8745 let mut _prev_end_offset: usize = 0;
8746 if 1 > max_ordinal {
8747 return Ok(());
8748 }
8749
8750 let cur_offset: usize = (1 - 1) * envelope_size;
8753
8754 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8756
8757 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8762 self.le_privacy.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8763 encoder,
8764 offset + cur_offset,
8765 depth,
8766 )?;
8767
8768 _prev_end_offset = cur_offset + envelope_size;
8769 if 2 > max_ordinal {
8770 return Ok(());
8771 }
8772
8773 let cur_offset: usize = (2 - 1) * envelope_size;
8776
8777 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8779
8780 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8785 self.le_background_scan
8786 .as_ref()
8787 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8788 encoder,
8789 offset + cur_offset,
8790 depth,
8791 )?;
8792
8793 _prev_end_offset = cur_offset + envelope_size;
8794 if 3 > max_ordinal {
8795 return Ok(());
8796 }
8797
8798 let cur_offset: usize = (3 - 1) * envelope_size;
8801
8802 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8804
8805 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8810 self.bredr_connectable_mode
8811 .as_ref()
8812 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8813 encoder,
8814 offset + cur_offset,
8815 depth,
8816 )?;
8817
8818 _prev_end_offset = cur_offset + envelope_size;
8819 if 4 > max_ordinal {
8820 return Ok(());
8821 }
8822
8823 let cur_offset: usize = (4 - 1) * envelope_size;
8826
8827 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8829
8830 fidl::encoding::encode_in_envelope_optional::<LeSecurityMode, D>(
8835 self.le_security_mode
8836 .as_ref()
8837 .map(<LeSecurityMode as fidl::encoding::ValueTypeMarker>::borrow),
8838 encoder,
8839 offset + cur_offset,
8840 depth,
8841 )?;
8842
8843 _prev_end_offset = cur_offset + envelope_size;
8844 if 5 > max_ordinal {
8845 return Ok(());
8846 }
8847
8848 let cur_offset: usize = (5 - 1) * envelope_size;
8851
8852 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8854
8855 fidl::encoding::encode_in_envelope_optional::<BrEdrSecurityMode, D>(
8860 self.bredr_security_mode
8861 .as_ref()
8862 .map(<BrEdrSecurityMode as fidl::encoding::ValueTypeMarker>::borrow),
8863 encoder,
8864 offset + cur_offset,
8865 depth,
8866 )?;
8867
8868 _prev_end_offset = cur_offset + envelope_size;
8869
8870 Ok(())
8871 }
8872 }
8873
8874 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Settings {
8875 #[inline(always)]
8876 fn new_empty() -> Self {
8877 Self::default()
8878 }
8879
8880 unsafe fn decode(
8881 &mut self,
8882 decoder: &mut fidl::encoding::Decoder<'_, D>,
8883 offset: usize,
8884 mut depth: fidl::encoding::Depth,
8885 ) -> fidl::Result<()> {
8886 decoder.debug_check_bounds::<Self>(offset);
8887 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8888 None => return Err(fidl::Error::NotNullable),
8889 Some(len) => len,
8890 };
8891 if len == 0 {
8893 return Ok(());
8894 };
8895 depth.increment()?;
8896 let envelope_size = 8;
8897 let bytes_len = len * envelope_size;
8898 let offset = decoder.out_of_line_offset(bytes_len)?;
8899 let mut _next_ordinal_to_read = 0;
8901 let mut next_offset = offset;
8902 let end_offset = offset + bytes_len;
8903 _next_ordinal_to_read += 1;
8904 if next_offset >= end_offset {
8905 return Ok(());
8906 }
8907
8908 while _next_ordinal_to_read < 1 {
8910 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8911 _next_ordinal_to_read += 1;
8912 next_offset += envelope_size;
8913 }
8914
8915 let next_out_of_line = decoder.next_out_of_line();
8916 let handles_before = decoder.remaining_handles();
8917 if let Some((inlined, num_bytes, num_handles)) =
8918 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8919 {
8920 let member_inline_size =
8921 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8922 if inlined != (member_inline_size <= 4) {
8923 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8924 }
8925 let inner_offset;
8926 let mut inner_depth = depth.clone();
8927 if inlined {
8928 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8929 inner_offset = next_offset;
8930 } else {
8931 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8932 inner_depth.increment()?;
8933 }
8934 let val_ref = self.le_privacy.get_or_insert_with(|| fidl::new_empty!(bool, D));
8935 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8936 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8937 {
8938 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8939 }
8940 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8941 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8942 }
8943 }
8944
8945 next_offset += envelope_size;
8946 _next_ordinal_to_read += 1;
8947 if next_offset >= end_offset {
8948 return Ok(());
8949 }
8950
8951 while _next_ordinal_to_read < 2 {
8953 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8954 _next_ordinal_to_read += 1;
8955 next_offset += envelope_size;
8956 }
8957
8958 let next_out_of_line = decoder.next_out_of_line();
8959 let handles_before = decoder.remaining_handles();
8960 if let Some((inlined, num_bytes, num_handles)) =
8961 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8962 {
8963 let member_inline_size =
8964 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8965 if inlined != (member_inline_size <= 4) {
8966 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8967 }
8968 let inner_offset;
8969 let mut inner_depth = depth.clone();
8970 if inlined {
8971 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8972 inner_offset = next_offset;
8973 } else {
8974 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8975 inner_depth.increment()?;
8976 }
8977 let val_ref =
8978 self.le_background_scan.get_or_insert_with(|| fidl::new_empty!(bool, D));
8979 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8980 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8981 {
8982 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8983 }
8984 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8985 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8986 }
8987 }
8988
8989 next_offset += envelope_size;
8990 _next_ordinal_to_read += 1;
8991 if next_offset >= end_offset {
8992 return Ok(());
8993 }
8994
8995 while _next_ordinal_to_read < 3 {
8997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8998 _next_ordinal_to_read += 1;
8999 next_offset += envelope_size;
9000 }
9001
9002 let next_out_of_line = decoder.next_out_of_line();
9003 let handles_before = decoder.remaining_handles();
9004 if let Some((inlined, num_bytes, num_handles)) =
9005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9006 {
9007 let member_inline_size =
9008 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9009 if inlined != (member_inline_size <= 4) {
9010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9011 }
9012 let inner_offset;
9013 let mut inner_depth = depth.clone();
9014 if inlined {
9015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9016 inner_offset = next_offset;
9017 } else {
9018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9019 inner_depth.increment()?;
9020 }
9021 let val_ref =
9022 self.bredr_connectable_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
9023 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9024 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9025 {
9026 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9027 }
9028 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9029 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9030 }
9031 }
9032
9033 next_offset += envelope_size;
9034 _next_ordinal_to_read += 1;
9035 if next_offset >= end_offset {
9036 return Ok(());
9037 }
9038
9039 while _next_ordinal_to_read < 4 {
9041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9042 _next_ordinal_to_read += 1;
9043 next_offset += envelope_size;
9044 }
9045
9046 let next_out_of_line = decoder.next_out_of_line();
9047 let handles_before = decoder.remaining_handles();
9048 if let Some((inlined, num_bytes, num_handles)) =
9049 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9050 {
9051 let member_inline_size =
9052 <LeSecurityMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9053 if inlined != (member_inline_size <= 4) {
9054 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9055 }
9056 let inner_offset;
9057 let mut inner_depth = depth.clone();
9058 if inlined {
9059 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9060 inner_offset = next_offset;
9061 } else {
9062 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9063 inner_depth.increment()?;
9064 }
9065 let val_ref = self
9066 .le_security_mode
9067 .get_or_insert_with(|| fidl::new_empty!(LeSecurityMode, D));
9068 fidl::decode!(LeSecurityMode, D, val_ref, decoder, inner_offset, inner_depth)?;
9069 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9070 {
9071 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9072 }
9073 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9074 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9075 }
9076 }
9077
9078 next_offset += envelope_size;
9079 _next_ordinal_to_read += 1;
9080 if next_offset >= end_offset {
9081 return Ok(());
9082 }
9083
9084 while _next_ordinal_to_read < 5 {
9086 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9087 _next_ordinal_to_read += 1;
9088 next_offset += envelope_size;
9089 }
9090
9091 let next_out_of_line = decoder.next_out_of_line();
9092 let handles_before = decoder.remaining_handles();
9093 if let Some((inlined, num_bytes, num_handles)) =
9094 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9095 {
9096 let member_inline_size =
9097 <BrEdrSecurityMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9098 if inlined != (member_inline_size <= 4) {
9099 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9100 }
9101 let inner_offset;
9102 let mut inner_depth = depth.clone();
9103 if inlined {
9104 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9105 inner_offset = next_offset;
9106 } else {
9107 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9108 inner_depth.increment()?;
9109 }
9110 let val_ref = self
9111 .bredr_security_mode
9112 .get_or_insert_with(|| fidl::new_empty!(BrEdrSecurityMode, D));
9113 fidl::decode!(BrEdrSecurityMode, D, val_ref, decoder, inner_offset, inner_depth)?;
9114 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9115 {
9116 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9117 }
9118 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9119 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9120 }
9121 }
9122
9123 next_offset += envelope_size;
9124
9125 while next_offset < end_offset {
9127 _next_ordinal_to_read += 1;
9128 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9129 next_offset += envelope_size;
9130 }
9131
9132 Ok(())
9133 }
9134 }
9135
9136 impl fidl::encoding::ValueTypeMarker for PairingProperties {
9137 type Borrowed<'a> = &'a Self;
9138 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9139 value
9140 }
9141 }
9142
9143 unsafe impl fidl::encoding::TypeMarker for PairingProperties {
9144 type Owned = Self;
9145
9146 #[inline(always)]
9147 fn inline_align(_context: fidl::encoding::Context) -> usize {
9148 8
9149 }
9150
9151 #[inline(always)]
9152 fn inline_size(_context: fidl::encoding::Context) -> usize {
9153 16
9154 }
9155 }
9156
9157 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PairingProperties, D>
9158 for &PairingProperties
9159 {
9160 #[inline]
9161 unsafe fn encode(
9162 self,
9163 encoder: &mut fidl::encoding::Encoder<'_, D>,
9164 offset: usize,
9165 _depth: fidl::encoding::Depth,
9166 ) -> fidl::Result<()> {
9167 encoder.debug_check_bounds::<PairingProperties>(offset);
9168 encoder.write_num::<u64>(self.ordinal(), offset);
9169 match self {
9170 PairingProperties::Consent(ref val) => {
9171 fidl::encoding::encode_in_envelope::<Consent, D>(
9172 <Consent as fidl::encoding::ValueTypeMarker>::borrow(val),
9173 encoder,
9174 offset + 8,
9175 _depth,
9176 )
9177 }
9178 PairingProperties::PasskeyDisplay(ref val) => {
9179 fidl::encoding::encode_in_envelope::<u32, D>(
9180 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
9181 encoder,
9182 offset + 8,
9183 _depth,
9184 )
9185 }
9186 PairingProperties::PasskeyConfirmation(ref val) => {
9187 fidl::encoding::encode_in_envelope::<u32, D>(
9188 <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
9189 encoder,
9190 offset + 8,
9191 _depth,
9192 )
9193 }
9194 PairingProperties::PasskeyEntry(ref val) => {
9195 fidl::encoding::encode_in_envelope::<PasskeyEntry, D>(
9196 <PasskeyEntry as fidl::encoding::ValueTypeMarker>::borrow(val),
9197 encoder,
9198 offset + 8,
9199 _depth,
9200 )
9201 }
9202 PairingProperties::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
9203 }
9204 }
9205 }
9206
9207 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PairingProperties {
9208 #[inline(always)]
9209 fn new_empty() -> Self {
9210 Self::__SourceBreaking { unknown_ordinal: 0 }
9211 }
9212
9213 #[inline]
9214 unsafe fn decode(
9215 &mut self,
9216 decoder: &mut fidl::encoding::Decoder<'_, D>,
9217 offset: usize,
9218 mut depth: fidl::encoding::Depth,
9219 ) -> fidl::Result<()> {
9220 decoder.debug_check_bounds::<Self>(offset);
9221 #[allow(unused_variables)]
9222 let next_out_of_line = decoder.next_out_of_line();
9223 let handles_before = decoder.remaining_handles();
9224 let (ordinal, inlined, num_bytes, num_handles) =
9225 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
9226
9227 let member_inline_size = match ordinal {
9228 1 => <Consent as fidl::encoding::TypeMarker>::inline_size(decoder.context),
9229 2 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
9230 3 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
9231 4 => <PasskeyEntry as fidl::encoding::TypeMarker>::inline_size(decoder.context),
9232 0 => return Err(fidl::Error::UnknownUnionTag),
9233 _ => num_bytes as usize,
9234 };
9235
9236 if inlined != (member_inline_size <= 4) {
9237 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9238 }
9239 let _inner_offset;
9240 if inlined {
9241 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
9242 _inner_offset = offset + 8;
9243 } else {
9244 depth.increment()?;
9245 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9246 }
9247 match ordinal {
9248 1 => {
9249 #[allow(irrefutable_let_patterns)]
9250 if let PairingProperties::Consent(_) = self {
9251 } else {
9253 *self = PairingProperties::Consent(fidl::new_empty!(Consent, D));
9255 }
9256 #[allow(irrefutable_let_patterns)]
9257 if let PairingProperties::Consent(ref mut val) = self {
9258 fidl::decode!(Consent, D, val, decoder, _inner_offset, depth)?;
9259 } else {
9260 unreachable!()
9261 }
9262 }
9263 2 => {
9264 #[allow(irrefutable_let_patterns)]
9265 if let PairingProperties::PasskeyDisplay(_) = self {
9266 } else {
9268 *self = PairingProperties::PasskeyDisplay(fidl::new_empty!(u32, D));
9270 }
9271 #[allow(irrefutable_let_patterns)]
9272 if let PairingProperties::PasskeyDisplay(ref mut val) = self {
9273 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
9274 } else {
9275 unreachable!()
9276 }
9277 }
9278 3 => {
9279 #[allow(irrefutable_let_patterns)]
9280 if let PairingProperties::PasskeyConfirmation(_) = self {
9281 } else {
9283 *self = PairingProperties::PasskeyConfirmation(fidl::new_empty!(u32, D));
9285 }
9286 #[allow(irrefutable_let_patterns)]
9287 if let PairingProperties::PasskeyConfirmation(ref mut val) = self {
9288 fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
9289 } else {
9290 unreachable!()
9291 }
9292 }
9293 4 => {
9294 #[allow(irrefutable_let_patterns)]
9295 if let PairingProperties::PasskeyEntry(_) = self {
9296 } else {
9298 *self = PairingProperties::PasskeyEntry(fidl::new_empty!(PasskeyEntry, D));
9300 }
9301 #[allow(irrefutable_let_patterns)]
9302 if let PairingProperties::PasskeyEntry(ref mut val) = self {
9303 fidl::decode!(PasskeyEntry, D, val, decoder, _inner_offset, depth)?;
9304 } else {
9305 unreachable!()
9306 }
9307 }
9308 #[allow(deprecated)]
9309 ordinal => {
9310 for _ in 0..num_handles {
9311 decoder.drop_next_handle()?;
9312 }
9313 *self = PairingProperties::__SourceBreaking { unknown_ordinal: ordinal };
9314 }
9315 }
9316 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
9317 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9318 }
9319 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9320 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9321 }
9322 Ok(())
9323 }
9324 }
9325}