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 Psm = u16;
15
16pub const MAX_BROADCAST_NAME_OCTETS: u8 = 128;
17
18pub const MAX_ISO_PACKET_SIZE: u16 = 4095;
21
22pub const MAX_MANUFACTURER_DATA_LENGTH: u8 = 252;
23
24pub const MAX_SERVICE_DATA_LENGTH: u8 = 252;
25
26pub const MAX_STREAMS_IN_GROUP: u8 = 31;
29
30pub const MAX_URI_LENGTH: u16 = 278;
31
32#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
40#[repr(u8)]
41pub enum AdvertisingModeHint {
42 VeryFast = 1,
46 Fast = 2,
49 Slow = 3,
52}
53
54impl AdvertisingModeHint {
55 #[inline]
56 pub fn from_primitive(prim: u8) -> Option<Self> {
57 match prim {
58 1 => Some(Self::VeryFast),
59 2 => Some(Self::Fast),
60 3 => Some(Self::Slow),
61 _ => None,
62 }
63 }
64
65 #[inline]
66 pub const fn into_primitive(self) -> u8 {
67 self as u8
68 }
69}
70
71#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
72#[repr(u32)]
73pub enum CentralError {
74 Aborted = 1,
76 InProgress = 2,
78 InvalidParameters = 3,
80 Failed = 4,
82}
83
84impl CentralError {
85 #[inline]
86 pub fn from_primitive(prim: u32) -> Option<Self> {
87 match prim {
88 1 => Some(Self::Aborted),
89 2 => Some(Self::InProgress),
90 3 => Some(Self::InvalidParameters),
91 4 => Some(Self::Failed),
92 _ => None,
93 }
94 }
95
96 #[inline]
97 pub const fn into_primitive(self) -> u32 {
98 self as u32
99 }
100}
101
102#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
103#[repr(u32)]
104pub enum CigFramingOptions {
105 Unframed = 0,
106 Framed = 1,
107}
108
109impl CigFramingOptions {
110 #[inline]
111 pub fn from_primitive(prim: u32) -> Option<Self> {
112 match prim {
113 0 => Some(Self::Unframed),
114 1 => Some(Self::Framed),
115 _ => None,
116 }
117 }
118
119 #[inline]
120 pub const fn into_primitive(self) -> u32 {
121 self as u32
122 }
123}
124
125#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
126pub enum CigPacking {
127 Sequential,
128 Interleaved,
129 #[doc(hidden)]
130 __SourceBreaking {
131 unknown_ordinal: u32,
132 },
133}
134
135#[macro_export]
137macro_rules! CigPackingUnknown {
138 () => {
139 _
140 };
141}
142
143impl CigPacking {
144 #[inline]
145 pub fn from_primitive(prim: u32) -> Option<Self> {
146 match prim {
147 0 => Some(Self::Sequential),
148 1 => Some(Self::Interleaved),
149 _ => None,
150 }
151 }
152
153 #[inline]
154 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
155 match prim {
156 0 => Self::Sequential,
157 1 => Self::Interleaved,
158 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
159 }
160 }
161
162 #[inline]
163 pub fn unknown() -> Self {
164 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
165 }
166
167 #[inline]
168 pub const fn into_primitive(self) -> u32 {
169 match self {
170 Self::Sequential => 0,
171 Self::Interleaved => 1,
172 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
173 }
174 }
175
176 #[inline]
177 pub fn is_unknown(&self) -> bool {
178 match self {
179 Self::__SourceBreaking { unknown_ordinal: _ } => true,
180 _ => false,
181 }
182 }
183}
184
185#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
186pub enum CreateCigError {
187 Unknown,
190 NotEnoughResources,
192 InvalidCisParameters,
195 #[doc(hidden)]
196 __SourceBreaking { unknown_ordinal: u32 },
197}
198
199#[macro_export]
201macro_rules! CreateCigErrorUnknown {
202 () => {
203 _
204 };
205}
206
207impl CreateCigError {
208 #[inline]
209 pub fn from_primitive(prim: u32) -> Option<Self> {
210 match prim {
211 1 => Some(Self::Unknown),
212 2 => Some(Self::NotEnoughResources),
213 3 => Some(Self::InvalidCisParameters),
214 _ => None,
215 }
216 }
217
218 #[inline]
219 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
220 match prim {
221 1 => Self::Unknown,
222 2 => Self::NotEnoughResources,
223 3 => Self::InvalidCisParameters,
224 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
225 }
226 }
227
228 #[inline]
229 pub fn unknown() -> Self {
230 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
231 }
232
233 #[inline]
234 pub const fn into_primitive(self) -> u32 {
235 match self {
236 Self::Unknown => 1,
237 Self::NotEnoughResources => 2,
238 Self::InvalidCisParameters => 3,
239 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
240 }
241 }
242
243 #[inline]
244 pub fn is_unknown(&self) -> bool {
245 match self {
246 Self::__SourceBreaking { unknown_ordinal: _ } => true,
247 _ => false,
248 }
249 }
250}
251
252#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
253pub enum EstablishStreamsError {
254 NotSupported,
256 DuplicateCis,
258 CisAlreadyEstablished,
260 PeerNotConnected,
262 #[doc(hidden)]
263 __SourceBreaking { unknown_ordinal: u32 },
264}
265
266#[macro_export]
268macro_rules! EstablishStreamsErrorUnknown {
269 () => {
270 _
271 };
272}
273
274impl EstablishStreamsError {
275 #[inline]
276 pub fn from_primitive(prim: u32) -> Option<Self> {
277 match prim {
278 1 => Some(Self::NotSupported),
279 2 => Some(Self::DuplicateCis),
280 3 => Some(Self::CisAlreadyEstablished),
281 4 => Some(Self::PeerNotConnected),
282 _ => None,
283 }
284 }
285
286 #[inline]
287 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
288 match prim {
289 1 => Self::NotSupported,
290 2 => Self::DuplicateCis,
291 3 => Self::CisAlreadyEstablished,
292 4 => Self::PeerNotConnected,
293 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
294 }
295 }
296
297 #[inline]
298 pub fn unknown() -> Self {
299 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
300 }
301
302 #[inline]
303 pub const fn into_primitive(self) -> u32 {
304 match self {
305 Self::NotSupported => 1,
306 Self::DuplicateCis => 2,
307 Self::CisAlreadyEstablished => 3,
308 Self::PeerNotConnected => 4,
309 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
310 }
311 }
312
313 #[inline]
314 pub fn is_unknown(&self) -> bool {
315 match self {
316 Self::__SourceBreaking { unknown_ordinal: _ } => true,
317 _ => false,
318 }
319 }
320}
321
322#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
324#[repr(u8)]
325pub enum IsoPacketStatusFlag {
326 ValidData = 0,
328 DataWithPossibleErrors = 1,
331 LostData = 2,
333}
334
335impl IsoPacketStatusFlag {
336 #[inline]
337 pub fn from_primitive(prim: u8) -> Option<Self> {
338 match prim {
339 0 => Some(Self::ValidData),
340 1 => Some(Self::DataWithPossibleErrors),
341 2 => Some(Self::LostData),
342 _ => None,
343 }
344 }
345
346 #[inline]
347 pub const fn into_primitive(self) -> u8 {
348 self as u8
349 }
350}
351
352#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
353#[repr(u32)]
354pub enum PeripheralError {
355 NotSupported = 1,
357 AdvertisingDataTooLong = 2,
359 ScanResponseDataTooLong = 3,
361 InvalidParameters = 4,
363 Aborted = 5,
366 Failed = 6,
368}
369
370impl PeripheralError {
371 #[inline]
372 pub fn from_primitive(prim: u32) -> Option<Self> {
373 match prim {
374 1 => Some(Self::NotSupported),
375 2 => Some(Self::AdvertisingDataTooLong),
376 3 => Some(Self::ScanResponseDataTooLong),
377 4 => Some(Self::InvalidParameters),
378 5 => Some(Self::Aborted),
379 6 => Some(Self::Failed),
380 _ => None,
381 }
382 }
383
384 #[inline]
385 pub const fn into_primitive(self) -> u32 {
386 self as u32
387 }
388}
389
390#[derive(Clone, Debug, PartialEq)]
392pub struct AdvertisingDataDeprecated {
393 pub name: Option<String>,
395 pub tx_power_level: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
397 pub appearance: Option<Box<fidl_fuchsia_bluetooth__common::UInt16>>,
399 pub service_uuids: Option<Vec<String>>,
401 pub service_data: Option<Vec<ServiceDataEntry>>,
403 pub manufacturer_specific_data: Option<Vec<ManufacturerSpecificDataEntry>>,
405 pub solicited_service_uuids: Option<Vec<String>>,
408 pub uris: Option<Vec<String>>,
411}
412
413impl fidl::Persistable for AdvertisingDataDeprecated {}
414
415#[derive(Clone, Debug, PartialEq)]
416pub struct CentralConnectPeripheralResponse {
417 pub status: fidl_fuchsia_bluetooth__common::Status,
418}
419
420impl fidl::Persistable for CentralConnectPeripheralResponse {}
421
422#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
423pub struct CentralDisconnectPeripheralRequest {
424 pub identifier: String,
425}
426
427impl fidl::Persistable for CentralDisconnectPeripheralRequest {}
428
429#[derive(Clone, Debug, PartialEq)]
430pub struct CentralDisconnectPeripheralResponse {
431 pub status: fidl_fuchsia_bluetooth__common::Status,
432}
433
434impl fidl::Persistable for CentralDisconnectPeripheralResponse {}
435
436#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
437pub struct CentralGetPeripheralRequest {
438 pub identifier: String,
439}
440
441impl fidl::Persistable for CentralGetPeripheralRequest {}
442
443#[derive(Clone, Debug, PartialEq)]
444pub struct CentralGetPeripheralResponse {
445 pub peripheral: Option<Box<RemoteDevice>>,
446}
447
448impl fidl::Persistable for CentralGetPeripheralResponse {}
449
450#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
451pub struct CentralGetPeripheralsRequest {
452 pub service_uuids: Option<Vec<String>>,
453}
454
455impl fidl::Persistable for CentralGetPeripheralsRequest {}
456
457#[derive(Clone, Debug, PartialEq)]
458pub struct CentralGetPeripheralsResponse {
459 pub peripherals: Vec<RemoteDevice>,
460}
461
462impl fidl::Persistable for CentralGetPeripheralsResponse {}
463
464#[derive(Clone, Debug, PartialEq)]
465pub struct CentralOnDeviceDiscoveredRequest {
466 pub device: RemoteDevice,
467}
468
469impl fidl::Persistable for CentralOnDeviceDiscoveredRequest {}
470
471#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
472pub struct CentralOnPeripheralDisconnectedRequest {
473 pub identifier: String,
474}
475
476impl fidl::Persistable for CentralOnPeripheralDisconnectedRequest {}
477
478#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
479pub struct CentralOnScanStateChangedRequest {
480 pub scanning: bool,
481}
482
483impl fidl::Persistable for CentralOnScanStateChangedRequest {}
484
485#[derive(Clone, Debug, PartialEq)]
486pub struct CentralStartScanRequest {
487 pub filter: Option<Box<ScanFilter>>,
488}
489
490impl fidl::Persistable for CentralStartScanRequest {}
491
492#[derive(Clone, Debug, PartialEq)]
493pub struct CentralStartScanResponse {
494 pub status: fidl_fuchsia_bluetooth__common::Status,
495}
496
497impl fidl::Persistable for CentralStartScanResponse {}
498
499#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
501pub struct ManufacturerData {
502 pub company_id: u16,
503 pub data: Vec<u8>,
504}
505
506impl fidl::Persistable for ManufacturerData {}
507
508#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
509pub struct ManufacturerSpecificDataEntry {
510 pub company_id: u16,
511 pub data: Vec<u8>,
512}
513
514impl fidl::Persistable for ManufacturerSpecificDataEntry {}
515
516#[derive(Clone, Debug, PartialEq)]
519pub struct RemoteDevice {
520 pub identifier: String,
522 pub connectable: bool,
525 pub rssi: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
527 pub advertising_data: Option<Box<AdvertisingDataDeprecated>>,
529}
530
531impl fidl::Persistable for RemoteDevice {}
532
533#[derive(Clone, Debug, PartialEq)]
537pub struct ScanFilter {
538 pub service_uuids: Option<Vec<String>>,
541 pub service_data_uuids: Option<Vec<String>>,
543 pub manufacturer_identifier: Option<Box<fidl_fuchsia_bluetooth__common::UInt16>>,
547 pub connectable: Option<Box<fidl_fuchsia_bluetooth__common::Bool>>,
551 pub name_substring: Option<String>,
553 pub max_path_loss: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
559}
560
561impl fidl::Persistable for ScanFilter {}
562
563#[derive(Clone, Debug, PartialEq)]
564pub struct ScanResultWatcherWatchResponse {
565 pub updated: Vec<Peer>,
566}
567
568impl fidl::Persistable for ScanResultWatcherWatchResponse {}
569
570#[derive(Clone, Debug, PartialEq)]
572pub struct ServiceData {
573 pub uuid: fidl_fuchsia_bluetooth__common::Uuid,
574 pub data: Vec<u8>,
575}
576
577impl fidl::Persistable for ServiceData {}
578
579#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
580pub struct ServiceDataEntry {
581 pub uuid: String,
582 pub data: Vec<u8>,
583}
584
585impl fidl::Persistable for ServiceDataEntry {}
586
587#[derive(Clone, Debug, Default, PartialEq)]
592pub struct AcceptedChannelParameters {
593 pub accepted_channel_modes: Option<Vec<fidl_fuchsia_bluetooth__common::ChannelMode>>,
598 pub max_packet_size: Option<u16>,
602 #[doc(hidden)]
603 pub __source_breaking: fidl::marker::SourceBreaking,
604}
605
606impl fidl::Persistable for AcceptedChannelParameters {}
607
608#[derive(Clone, Debug, Default, PartialEq)]
611pub struct AdvertisingData {
612 pub name: Option<String>,
614 pub appearance: Option<fidl_fuchsia_bluetooth__common::Appearance>,
616 pub tx_power_level: Option<i8>,
617 pub service_uuids: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
619 pub service_data: Option<Vec<ServiceData>>,
621 pub manufacturer_data: Option<Vec<ManufacturerData>>,
623 pub uris: Option<Vec<String>>,
629 pub include_tx_power_level: Option<bool>,
631 pub resolvable_set_identifier: Option<[u8; 6]>,
635 pub broadcast_name: Option<String>,
644 #[doc(hidden)]
645 pub __source_breaking: fidl::marker::SourceBreaking,
646}
647
648impl fidl::Persistable for AdvertisingData {}
649
650#[derive(Clone, Debug, Default, PartialEq)]
652pub struct AdvertisingParameters {
653 pub data: Option<AdvertisingData>,
657 pub scan_response: Option<AdvertisingData>,
663 pub mode_hint: Option<AdvertisingModeHint>,
666 pub connectable: Option<bool>,
670 pub connection_options: Option<ConnectionOptions>,
675 pub advertising_procedure: Option<AdvertisingProcedure>,
681 pub address_type: Option<fidl_fuchsia_bluetooth__common::AddressType>,
693 #[doc(hidden)]
694 pub __source_breaking: fidl::marker::SourceBreaking,
695}
696
697impl fidl::Persistable for AdvertisingParameters {}
698
699#[derive(Clone, Debug, Default, PartialEq)]
700pub struct CentralCreateConnectedIsochronousGroupResponse {
701 pub cig_id: Option<u8>,
703 #[doc(hidden)]
704 pub __source_breaking: fidl::marker::SourceBreaking,
705}
706
707impl fidl::Persistable for CentralCreateConnectedIsochronousGroupResponse {}
708
709#[derive(Clone, Debug, Default, PartialEq)]
710pub struct ChannelListenerRegistryListenL2capResponse {
711 pub psm: Option<u16>,
714 #[doc(hidden)]
715 pub __source_breaking: fidl::marker::SourceBreaking,
716}
717
718impl fidl::Persistable for ChannelListenerRegistryListenL2capResponse {}
719
720#[derive(Clone, Debug, Default, PartialEq)]
721pub struct CigParameters {
722 pub sdu_interval_c_to_p: Option<u32>,
726 pub sdu_interval_p_to_c: Option<u32>,
730 pub packing: Option<CigPacking>,
734 pub framing: Option<CigFramingOptions>,
737 pub max_transport_latency_c_to_p: Option<u16>,
741 pub max_transport_latency_p_to_c: Option<u16>,
745 #[doc(hidden)]
746 pub __source_breaking: fidl::marker::SourceBreaking,
747}
748
749impl fidl::Persistable for CigParameters {}
750
751#[derive(Clone, Debug, Default, PartialEq)]
753pub struct CisEstablishedParameters {
754 pub cig_sync_delay: Option<i64>,
759 pub cis_sync_delay: Option<i64>,
764 pub max_subevents: Option<u8>,
768 pub iso_interval: Option<i64>,
772 pub central_to_peripheral_params: Option<CisUnidirectionalParams>,
777 pub peripheral_to_central_params: Option<CisUnidirectionalParams>,
782 #[doc(hidden)]
783 pub __source_breaking: fidl::marker::SourceBreaking,
784}
785
786impl fidl::Persistable for CisEstablishedParameters {}
787
788#[derive(Clone, Debug, Default, PartialEq)]
789pub struct CisParameters {
790 pub cis_id: Option<u8>,
793 pub id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
796 #[doc(hidden)]
797 pub __source_breaking: fidl::marker::SourceBreaking,
798}
799
800impl fidl::Persistable for CisParameters {}
801
802#[derive(Clone, Debug, Default, PartialEq)]
804pub struct CisUnidirectionalParams {
805 pub transport_latency: Option<i64>,
809 pub burst_number: Option<u8>,
813 pub flush_timeout: Option<u8>,
817 #[doc(hidden)]
818 pub __source_breaking: fidl::marker::SourceBreaking,
819}
820
821impl fidl::Persistable for CisUnidirectionalParams {}
822
823#[derive(Clone, Debug, Default, PartialEq)]
824pub struct CodecDelayGetCodecLocalDelayRangeRequest {
825 pub logical_transport_type: Option<fidl_fuchsia_bluetooth__common::LogicalTransportType>,
828 pub data_direction: Option<fidl_fuchsia_bluetooth__common::DataDirection>,
830 pub codec_attributes: Option<fidl_fuchsia_bluetooth__common::CodecAttributes>,
832 #[doc(hidden)]
833 pub __source_breaking: fidl::marker::SourceBreaking,
834}
835
836impl fidl::Persistable for CodecDelayGetCodecLocalDelayRangeRequest {}
837
838#[derive(Clone, Debug, Default, PartialEq)]
839pub struct CodecDelayGetCodecLocalDelayRangeResponse {
840 pub min_controller_delay: Option<i64>,
843 pub max_controller_delay: Option<i64>,
846 #[doc(hidden)]
847 pub __source_breaking: fidl::marker::SourceBreaking,
848}
849
850impl fidl::Persistable for CodecDelayGetCodecLocalDelayRangeResponse {}
851
852#[derive(Clone, Debug, Default, PartialEq)]
853pub struct ConnectedIsochronousGroupEstablishStreamsRequest {
854 pub cis_params: Option<Vec<CisParameters>>,
856 #[doc(hidden)]
857 pub __source_breaking: fidl::marker::SourceBreaking,
858}
859
860impl fidl::Persistable for ConnectedIsochronousGroupEstablishStreamsRequest {}
861
862#[derive(Clone, Debug, Default, PartialEq)]
865pub struct ConnectionOptions {
866 pub bondable_mode: Option<bool>,
871 pub service_filter: Option<fidl_fuchsia_bluetooth__common::Uuid>,
874 #[doc(hidden)]
875 pub __source_breaking: fidl::marker::SourceBreaking,
876}
877
878impl fidl::Persistable for ConnectionOptions {}
879
880#[derive(Clone, Debug, Default, PartialEq)]
881pub struct Extended {
882 #[doc(hidden)]
883 pub __source_breaking: fidl::marker::SourceBreaking,
884}
885
886impl fidl::Persistable for Extended {}
887
888#[derive(Clone, Debug, Default, PartialEq)]
891pub struct Filter {
892 pub service_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
894 pub service_data_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
896 pub manufacturer_id: Option<u16>,
902 pub connectable: Option<bool>,
907 pub name: Option<String>,
910 pub max_path_loss: Option<i8>,
922 pub solicitation_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
926 #[doc(hidden)]
927 pub __source_breaking: fidl::marker::SourceBreaking,
928}
929
930impl fidl::Persistable for Filter {}
931
932#[derive(Clone, Debug, Default, PartialEq)]
933pub struct IsochronousStreamOnEstablishedRequest {
934 pub result: Option<i32>,
937 pub established_params: Option<CisEstablishedParameters>,
939 #[doc(hidden)]
940 pub __source_breaking: fidl::marker::SourceBreaking,
941}
942
943impl fidl::Persistable for IsochronousStreamOnEstablishedRequest {}
944
945#[derive(Clone, Debug, Default, PartialEq)]
946pub struct IsochronousStreamSetupDataPathRequest {
947 pub data_direction: Option<fidl_fuchsia_bluetooth__common::DataDirection>,
950 pub codec_attributes: Option<fidl_fuchsia_bluetooth__common::CodecAttributes>,
953 pub controller_delay: Option<i64>,
957 #[doc(hidden)]
958 pub __source_breaking: fidl::marker::SourceBreaking,
959}
960
961impl fidl::Persistable for IsochronousStreamSetupDataPathRequest {}
962
963#[derive(Clone, Debug, Default, PartialEq)]
964pub struct IsochronousStreamWriteRequest {
965 pub data: Option<Vec<u8>>,
967 #[doc(hidden)]
968 pub __source_breaking: fidl::marker::SourceBreaking,
969}
970
971impl fidl::Persistable for IsochronousStreamWriteRequest {}
972
973#[derive(Clone, Debug, Default, PartialEq)]
974pub struct IsochronousStreamReadResponse {
975 pub data: Option<Vec<u8>>,
978 pub sequence_number: Option<u16>,
981 pub status_flag: Option<IsoPacketStatusFlag>,
984 pub timestamp: Option<i64>,
987 #[doc(hidden)]
988 pub __source_breaking: fidl::marker::SourceBreaking,
989}
990
991impl fidl::Persistable for IsochronousStreamReadResponse {}
992
993#[derive(Clone, Debug, Default, PartialEq)]
994pub struct Legacy {
995 #[doc(hidden)]
996 pub __source_breaking: fidl::marker::SourceBreaking,
997}
998
999impl fidl::Persistable for Legacy {}
1000
1001#[derive(Clone, Debug, Default, PartialEq)]
1004pub struct Peer {
1005 pub id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
1009 pub connectable: Option<bool>,
1014 pub rssi: Option<i8>,
1020 pub advertising_data: Option<AdvertisingData>,
1021 pub name: Option<String>,
1026 pub data: Option<ScanData>,
1029 pub bonded: Option<bool>,
1033 pub last_updated: Option<i64>,
1038 pub advertising_sid: Option<u8>,
1042 pub periodic_advertising_interval: Option<u16>,
1046 #[doc(hidden)]
1047 pub __source_breaking: fidl::marker::SourceBreaking,
1048}
1049
1050impl fidl::Persistable for Peer {}
1051
1052#[derive(Clone, Debug, Default, PartialEq)]
1054pub struct ScanData {
1055 pub tx_power: Option<i8>,
1060 pub appearance: Option<fidl_fuchsia_bluetooth__common::Appearance>,
1062 pub service_uuids: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
1064 pub service_data: Option<Vec<ServiceData>>,
1066 pub manufacturer_data: Option<Vec<ManufacturerData>>,
1068 pub uris: Option<Vec<String>>,
1074 pub timestamp: Option<i64>,
1076 #[doc(hidden)]
1077 pub __source_breaking: fidl::marker::SourceBreaking,
1078}
1079
1080impl fidl::Persistable for ScanData {}
1081
1082#[derive(Clone, Debug, Default, PartialEq)]
1084pub struct ScanOptions {
1085 pub filters: Option<Vec<Filter>>,
1090 #[doc(hidden)]
1091 pub __source_breaking: fidl::marker::SourceBreaking,
1092}
1093
1094impl fidl::Persistable for ScanOptions {}
1095
1096#[derive(Clone, Debug)]
1097pub enum AdvertisingProcedure {
1098 Legacy(Legacy),
1101 Extended(Extended),
1111 #[doc(hidden)]
1112 __SourceBreaking { unknown_ordinal: u64 },
1113}
1114
1115#[macro_export]
1117macro_rules! AdvertisingProcedureUnknown {
1118 () => {
1119 _
1120 };
1121}
1122
1123impl PartialEq for AdvertisingProcedure {
1125 fn eq(&self, other: &Self) -> bool {
1126 match (self, other) {
1127 (Self::Legacy(x), Self::Legacy(y)) => *x == *y,
1128 (Self::Extended(x), Self::Extended(y)) => *x == *y,
1129 _ => false,
1130 }
1131 }
1132}
1133
1134impl AdvertisingProcedure {
1135 #[inline]
1136 pub fn ordinal(&self) -> u64 {
1137 match *self {
1138 Self::Legacy(_) => 1,
1139 Self::Extended(_) => 2,
1140 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1141 }
1142 }
1143
1144 #[inline]
1145 pub fn unknown_variant_for_testing() -> Self {
1146 Self::__SourceBreaking { unknown_ordinal: 0 }
1147 }
1148
1149 #[inline]
1150 pub fn is_unknown(&self) -> bool {
1151 match self {
1152 Self::__SourceBreaking { .. } => true,
1153 _ => false,
1154 }
1155 }
1156}
1157
1158impl fidl::Persistable for AdvertisingProcedure {}
1159
1160mod internal {
1161 use super::*;
1162 unsafe impl fidl::encoding::TypeMarker for AdvertisingModeHint {
1163 type Owned = Self;
1164
1165 #[inline(always)]
1166 fn inline_align(_context: fidl::encoding::Context) -> usize {
1167 std::mem::align_of::<u8>()
1168 }
1169
1170 #[inline(always)]
1171 fn inline_size(_context: fidl::encoding::Context) -> usize {
1172 std::mem::size_of::<u8>()
1173 }
1174
1175 #[inline(always)]
1176 fn encode_is_copy() -> bool {
1177 true
1178 }
1179
1180 #[inline(always)]
1181 fn decode_is_copy() -> bool {
1182 false
1183 }
1184 }
1185
1186 impl fidl::encoding::ValueTypeMarker for AdvertisingModeHint {
1187 type Borrowed<'a> = Self;
1188 #[inline(always)]
1189 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1190 *value
1191 }
1192 }
1193
1194 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1195 for AdvertisingModeHint
1196 {
1197 #[inline]
1198 unsafe fn encode(
1199 self,
1200 encoder: &mut fidl::encoding::Encoder<'_, D>,
1201 offset: usize,
1202 _depth: fidl::encoding::Depth,
1203 ) -> fidl::Result<()> {
1204 encoder.debug_check_bounds::<Self>(offset);
1205 encoder.write_num(self.into_primitive(), offset);
1206 Ok(())
1207 }
1208 }
1209
1210 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingModeHint {
1211 #[inline(always)]
1212 fn new_empty() -> Self {
1213 Self::VeryFast
1214 }
1215
1216 #[inline]
1217 unsafe fn decode(
1218 &mut self,
1219 decoder: &mut fidl::encoding::Decoder<'_, D>,
1220 offset: usize,
1221 _depth: fidl::encoding::Depth,
1222 ) -> fidl::Result<()> {
1223 decoder.debug_check_bounds::<Self>(offset);
1224 let prim = decoder.read_num::<u8>(offset);
1225
1226 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1227 Ok(())
1228 }
1229 }
1230 unsafe impl fidl::encoding::TypeMarker for CentralError {
1231 type Owned = Self;
1232
1233 #[inline(always)]
1234 fn inline_align(_context: fidl::encoding::Context) -> usize {
1235 std::mem::align_of::<u32>()
1236 }
1237
1238 #[inline(always)]
1239 fn inline_size(_context: fidl::encoding::Context) -> usize {
1240 std::mem::size_of::<u32>()
1241 }
1242
1243 #[inline(always)]
1244 fn encode_is_copy() -> bool {
1245 true
1246 }
1247
1248 #[inline(always)]
1249 fn decode_is_copy() -> bool {
1250 false
1251 }
1252 }
1253
1254 impl fidl::encoding::ValueTypeMarker for CentralError {
1255 type Borrowed<'a> = Self;
1256 #[inline(always)]
1257 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1258 *value
1259 }
1260 }
1261
1262 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CentralError {
1263 #[inline]
1264 unsafe fn encode(
1265 self,
1266 encoder: &mut fidl::encoding::Encoder<'_, D>,
1267 offset: usize,
1268 _depth: fidl::encoding::Depth,
1269 ) -> fidl::Result<()> {
1270 encoder.debug_check_bounds::<Self>(offset);
1271 encoder.write_num(self.into_primitive(), offset);
1272 Ok(())
1273 }
1274 }
1275
1276 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CentralError {
1277 #[inline(always)]
1278 fn new_empty() -> Self {
1279 Self::Aborted
1280 }
1281
1282 #[inline]
1283 unsafe fn decode(
1284 &mut self,
1285 decoder: &mut fidl::encoding::Decoder<'_, D>,
1286 offset: usize,
1287 _depth: fidl::encoding::Depth,
1288 ) -> fidl::Result<()> {
1289 decoder.debug_check_bounds::<Self>(offset);
1290 let prim = decoder.read_num::<u32>(offset);
1291
1292 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1293 Ok(())
1294 }
1295 }
1296 unsafe impl fidl::encoding::TypeMarker for CigFramingOptions {
1297 type Owned = Self;
1298
1299 #[inline(always)]
1300 fn inline_align(_context: fidl::encoding::Context) -> usize {
1301 std::mem::align_of::<u32>()
1302 }
1303
1304 #[inline(always)]
1305 fn inline_size(_context: fidl::encoding::Context) -> usize {
1306 std::mem::size_of::<u32>()
1307 }
1308
1309 #[inline(always)]
1310 fn encode_is_copy() -> bool {
1311 true
1312 }
1313
1314 #[inline(always)]
1315 fn decode_is_copy() -> bool {
1316 false
1317 }
1318 }
1319
1320 impl fidl::encoding::ValueTypeMarker for CigFramingOptions {
1321 type Borrowed<'a> = Self;
1322 #[inline(always)]
1323 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1324 *value
1325 }
1326 }
1327
1328 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1329 for CigFramingOptions
1330 {
1331 #[inline]
1332 unsafe fn encode(
1333 self,
1334 encoder: &mut fidl::encoding::Encoder<'_, D>,
1335 offset: usize,
1336 _depth: fidl::encoding::Depth,
1337 ) -> fidl::Result<()> {
1338 encoder.debug_check_bounds::<Self>(offset);
1339 encoder.write_num(self.into_primitive(), offset);
1340 Ok(())
1341 }
1342 }
1343
1344 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigFramingOptions {
1345 #[inline(always)]
1346 fn new_empty() -> Self {
1347 Self::Unframed
1348 }
1349
1350 #[inline]
1351 unsafe fn decode(
1352 &mut self,
1353 decoder: &mut fidl::encoding::Decoder<'_, D>,
1354 offset: usize,
1355 _depth: fidl::encoding::Depth,
1356 ) -> fidl::Result<()> {
1357 decoder.debug_check_bounds::<Self>(offset);
1358 let prim = decoder.read_num::<u32>(offset);
1359
1360 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1361 Ok(())
1362 }
1363 }
1364 unsafe impl fidl::encoding::TypeMarker for CigPacking {
1365 type Owned = Self;
1366
1367 #[inline(always)]
1368 fn inline_align(_context: fidl::encoding::Context) -> usize {
1369 std::mem::align_of::<u32>()
1370 }
1371
1372 #[inline(always)]
1373 fn inline_size(_context: fidl::encoding::Context) -> usize {
1374 std::mem::size_of::<u32>()
1375 }
1376
1377 #[inline(always)]
1378 fn encode_is_copy() -> bool {
1379 false
1380 }
1381
1382 #[inline(always)]
1383 fn decode_is_copy() -> bool {
1384 false
1385 }
1386 }
1387
1388 impl fidl::encoding::ValueTypeMarker for CigPacking {
1389 type Borrowed<'a> = Self;
1390 #[inline(always)]
1391 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1392 *value
1393 }
1394 }
1395
1396 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CigPacking {
1397 #[inline]
1398 unsafe fn encode(
1399 self,
1400 encoder: &mut fidl::encoding::Encoder<'_, D>,
1401 offset: usize,
1402 _depth: fidl::encoding::Depth,
1403 ) -> fidl::Result<()> {
1404 encoder.debug_check_bounds::<Self>(offset);
1405 encoder.write_num(self.into_primitive(), offset);
1406 Ok(())
1407 }
1408 }
1409
1410 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigPacking {
1411 #[inline(always)]
1412 fn new_empty() -> Self {
1413 Self::unknown()
1414 }
1415
1416 #[inline]
1417 unsafe fn decode(
1418 &mut self,
1419 decoder: &mut fidl::encoding::Decoder<'_, D>,
1420 offset: usize,
1421 _depth: fidl::encoding::Depth,
1422 ) -> fidl::Result<()> {
1423 decoder.debug_check_bounds::<Self>(offset);
1424 let prim = decoder.read_num::<u32>(offset);
1425
1426 *self = Self::from_primitive_allow_unknown(prim);
1427 Ok(())
1428 }
1429 }
1430 unsafe impl fidl::encoding::TypeMarker for CreateCigError {
1431 type Owned = Self;
1432
1433 #[inline(always)]
1434 fn inline_align(_context: fidl::encoding::Context) -> usize {
1435 std::mem::align_of::<u32>()
1436 }
1437
1438 #[inline(always)]
1439 fn inline_size(_context: fidl::encoding::Context) -> usize {
1440 std::mem::size_of::<u32>()
1441 }
1442
1443 #[inline(always)]
1444 fn encode_is_copy() -> bool {
1445 false
1446 }
1447
1448 #[inline(always)]
1449 fn decode_is_copy() -> bool {
1450 false
1451 }
1452 }
1453
1454 impl fidl::encoding::ValueTypeMarker for CreateCigError {
1455 type Borrowed<'a> = Self;
1456 #[inline(always)]
1457 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1458 *value
1459 }
1460 }
1461
1462 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateCigError {
1463 #[inline]
1464 unsafe fn encode(
1465 self,
1466 encoder: &mut fidl::encoding::Encoder<'_, D>,
1467 offset: usize,
1468 _depth: fidl::encoding::Depth,
1469 ) -> fidl::Result<()> {
1470 encoder.debug_check_bounds::<Self>(offset);
1471 encoder.write_num(self.into_primitive(), offset);
1472 Ok(())
1473 }
1474 }
1475
1476 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateCigError {
1477 #[inline(always)]
1478 fn new_empty() -> Self {
1479 Self::unknown()
1480 }
1481
1482 #[inline]
1483 unsafe fn decode(
1484 &mut self,
1485 decoder: &mut fidl::encoding::Decoder<'_, D>,
1486 offset: usize,
1487 _depth: fidl::encoding::Depth,
1488 ) -> fidl::Result<()> {
1489 decoder.debug_check_bounds::<Self>(offset);
1490 let prim = decoder.read_num::<u32>(offset);
1491
1492 *self = Self::from_primitive_allow_unknown(prim);
1493 Ok(())
1494 }
1495 }
1496 unsafe impl fidl::encoding::TypeMarker for EstablishStreamsError {
1497 type Owned = Self;
1498
1499 #[inline(always)]
1500 fn inline_align(_context: fidl::encoding::Context) -> usize {
1501 std::mem::align_of::<u32>()
1502 }
1503
1504 #[inline(always)]
1505 fn inline_size(_context: fidl::encoding::Context) -> usize {
1506 std::mem::size_of::<u32>()
1507 }
1508
1509 #[inline(always)]
1510 fn encode_is_copy() -> bool {
1511 false
1512 }
1513
1514 #[inline(always)]
1515 fn decode_is_copy() -> bool {
1516 false
1517 }
1518 }
1519
1520 impl fidl::encoding::ValueTypeMarker for EstablishStreamsError {
1521 type Borrowed<'a> = Self;
1522 #[inline(always)]
1523 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1524 *value
1525 }
1526 }
1527
1528 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1529 for EstablishStreamsError
1530 {
1531 #[inline]
1532 unsafe fn encode(
1533 self,
1534 encoder: &mut fidl::encoding::Encoder<'_, D>,
1535 offset: usize,
1536 _depth: fidl::encoding::Depth,
1537 ) -> fidl::Result<()> {
1538 encoder.debug_check_bounds::<Self>(offset);
1539 encoder.write_num(self.into_primitive(), offset);
1540 Ok(())
1541 }
1542 }
1543
1544 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EstablishStreamsError {
1545 #[inline(always)]
1546 fn new_empty() -> Self {
1547 Self::unknown()
1548 }
1549
1550 #[inline]
1551 unsafe fn decode(
1552 &mut self,
1553 decoder: &mut fidl::encoding::Decoder<'_, D>,
1554 offset: usize,
1555 _depth: fidl::encoding::Depth,
1556 ) -> fidl::Result<()> {
1557 decoder.debug_check_bounds::<Self>(offset);
1558 let prim = decoder.read_num::<u32>(offset);
1559
1560 *self = Self::from_primitive_allow_unknown(prim);
1561 Ok(())
1562 }
1563 }
1564 unsafe impl fidl::encoding::TypeMarker for IsoPacketStatusFlag {
1565 type Owned = Self;
1566
1567 #[inline(always)]
1568 fn inline_align(_context: fidl::encoding::Context) -> usize {
1569 std::mem::align_of::<u8>()
1570 }
1571
1572 #[inline(always)]
1573 fn inline_size(_context: fidl::encoding::Context) -> usize {
1574 std::mem::size_of::<u8>()
1575 }
1576
1577 #[inline(always)]
1578 fn encode_is_copy() -> bool {
1579 true
1580 }
1581
1582 #[inline(always)]
1583 fn decode_is_copy() -> bool {
1584 false
1585 }
1586 }
1587
1588 impl fidl::encoding::ValueTypeMarker for IsoPacketStatusFlag {
1589 type Borrowed<'a> = Self;
1590 #[inline(always)]
1591 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1592 *value
1593 }
1594 }
1595
1596 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1597 for IsoPacketStatusFlag
1598 {
1599 #[inline]
1600 unsafe fn encode(
1601 self,
1602 encoder: &mut fidl::encoding::Encoder<'_, D>,
1603 offset: usize,
1604 _depth: fidl::encoding::Depth,
1605 ) -> fidl::Result<()> {
1606 encoder.debug_check_bounds::<Self>(offset);
1607 encoder.write_num(self.into_primitive(), offset);
1608 Ok(())
1609 }
1610 }
1611
1612 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IsoPacketStatusFlag {
1613 #[inline(always)]
1614 fn new_empty() -> Self {
1615 Self::ValidData
1616 }
1617
1618 #[inline]
1619 unsafe fn decode(
1620 &mut self,
1621 decoder: &mut fidl::encoding::Decoder<'_, D>,
1622 offset: usize,
1623 _depth: fidl::encoding::Depth,
1624 ) -> fidl::Result<()> {
1625 decoder.debug_check_bounds::<Self>(offset);
1626 let prim = decoder.read_num::<u8>(offset);
1627
1628 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1629 Ok(())
1630 }
1631 }
1632 unsafe impl fidl::encoding::TypeMarker for PeripheralError {
1633 type Owned = Self;
1634
1635 #[inline(always)]
1636 fn inline_align(_context: fidl::encoding::Context) -> usize {
1637 std::mem::align_of::<u32>()
1638 }
1639
1640 #[inline(always)]
1641 fn inline_size(_context: fidl::encoding::Context) -> usize {
1642 std::mem::size_of::<u32>()
1643 }
1644
1645 #[inline(always)]
1646 fn encode_is_copy() -> bool {
1647 true
1648 }
1649
1650 #[inline(always)]
1651 fn decode_is_copy() -> bool {
1652 false
1653 }
1654 }
1655
1656 impl fidl::encoding::ValueTypeMarker for PeripheralError {
1657 type Borrowed<'a> = Self;
1658 #[inline(always)]
1659 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1660 *value
1661 }
1662 }
1663
1664 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1665 for PeripheralError
1666 {
1667 #[inline]
1668 unsafe fn encode(
1669 self,
1670 encoder: &mut fidl::encoding::Encoder<'_, D>,
1671 offset: usize,
1672 _depth: fidl::encoding::Depth,
1673 ) -> fidl::Result<()> {
1674 encoder.debug_check_bounds::<Self>(offset);
1675 encoder.write_num(self.into_primitive(), offset);
1676 Ok(())
1677 }
1678 }
1679
1680 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeripheralError {
1681 #[inline(always)]
1682 fn new_empty() -> Self {
1683 Self::NotSupported
1684 }
1685
1686 #[inline]
1687 unsafe fn decode(
1688 &mut self,
1689 decoder: &mut fidl::encoding::Decoder<'_, D>,
1690 offset: usize,
1691 _depth: fidl::encoding::Depth,
1692 ) -> fidl::Result<()> {
1693 decoder.debug_check_bounds::<Self>(offset);
1694 let prim = decoder.read_num::<u32>(offset);
1695
1696 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1697 Ok(())
1698 }
1699 }
1700
1701 impl fidl::encoding::ValueTypeMarker for AdvertisingDataDeprecated {
1702 type Borrowed<'a> = &'a Self;
1703 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1704 value
1705 }
1706 }
1707
1708 unsafe impl fidl::encoding::TypeMarker for AdvertisingDataDeprecated {
1709 type Owned = Self;
1710
1711 #[inline(always)]
1712 fn inline_align(_context: fidl::encoding::Context) -> usize {
1713 8
1714 }
1715
1716 #[inline(always)]
1717 fn inline_size(_context: fidl::encoding::Context) -> usize {
1718 112
1719 }
1720 }
1721
1722 unsafe impl<D: fidl::encoding::ResourceDialect>
1723 fidl::encoding::Encode<AdvertisingDataDeprecated, D> for &AdvertisingDataDeprecated
1724 {
1725 #[inline]
1726 unsafe fn encode(
1727 self,
1728 encoder: &mut fidl::encoding::Encoder<'_, D>,
1729 offset: usize,
1730 _depth: fidl::encoding::Depth,
1731 ) -> fidl::Result<()> {
1732 encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1733 fidl::encoding::Encode::<AdvertisingDataDeprecated, D>::encode(
1735 (
1736 <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1737 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.tx_power_level),
1738 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.appearance),
1739 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
1740 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data),
1741 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_specific_data),
1742 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.solicited_service_uuids),
1743 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>> as fidl::encoding::ValueTypeMarker>::borrow(&self.uris),
1744 ),
1745 encoder, offset, _depth
1746 )
1747 }
1748 }
1749 unsafe impl<
1750 D: fidl::encoding::ResourceDialect,
1751 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
1752 T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
1753 T2: fidl::encoding::Encode<
1754 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1755 D,
1756 >,
1757 T3: fidl::encoding::Encode<
1758 fidl::encoding::Optional<
1759 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1760 >,
1761 D,
1762 >,
1763 T4: fidl::encoding::Encode<
1764 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1765 D,
1766 >,
1767 T5: fidl::encoding::Encode<
1768 fidl::encoding::Optional<
1769 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1770 >,
1771 D,
1772 >,
1773 T6: fidl::encoding::Encode<
1774 fidl::encoding::Optional<
1775 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1776 >,
1777 D,
1778 >,
1779 T7: fidl::encoding::Encode<
1780 fidl::encoding::Optional<
1781 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1782 >,
1783 D,
1784 >,
1785 > fidl::encoding::Encode<AdvertisingDataDeprecated, D>
1786 for (T0, T1, T2, T3, T4, T5, T6, T7)
1787 {
1788 #[inline]
1789 unsafe fn encode(
1790 self,
1791 encoder: &mut fidl::encoding::Encoder<'_, D>,
1792 offset: usize,
1793 depth: fidl::encoding::Depth,
1794 ) -> fidl::Result<()> {
1795 encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1796 self.0.encode(encoder, offset + 0, depth)?;
1800 self.1.encode(encoder, offset + 16, depth)?;
1801 self.2.encode(encoder, offset + 24, depth)?;
1802 self.3.encode(encoder, offset + 32, depth)?;
1803 self.4.encode(encoder, offset + 48, depth)?;
1804 self.5.encode(encoder, offset + 64, depth)?;
1805 self.6.encode(encoder, offset + 80, depth)?;
1806 self.7.encode(encoder, offset + 96, depth)?;
1807 Ok(())
1808 }
1809 }
1810
1811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1812 for AdvertisingDataDeprecated
1813 {
1814 #[inline(always)]
1815 fn new_empty() -> Self {
1816 Self {
1817 name: fidl::new_empty!(
1818 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1819 D
1820 ),
1821 tx_power_level: fidl::new_empty!(
1822 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1823 D
1824 ),
1825 appearance: fidl::new_empty!(
1826 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1827 D
1828 ),
1829 service_uuids: fidl::new_empty!(
1830 fidl::encoding::Optional<
1831 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1832 >,
1833 D
1834 ),
1835 service_data: fidl::new_empty!(
1836 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1837 D
1838 ),
1839 manufacturer_specific_data: fidl::new_empty!(
1840 fidl::encoding::Optional<
1841 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1842 >,
1843 D
1844 ),
1845 solicited_service_uuids: fidl::new_empty!(
1846 fidl::encoding::Optional<
1847 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1848 >,
1849 D
1850 ),
1851 uris: fidl::new_empty!(
1852 fidl::encoding::Optional<
1853 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1854 >,
1855 D
1856 ),
1857 }
1858 }
1859
1860 #[inline]
1861 unsafe fn decode(
1862 &mut self,
1863 decoder: &mut fidl::encoding::Decoder<'_, D>,
1864 offset: usize,
1865 _depth: fidl::encoding::Depth,
1866 ) -> fidl::Result<()> {
1867 decoder.debug_check_bounds::<Self>(offset);
1868 fidl::decode!(
1870 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1871 D,
1872 &mut self.name,
1873 decoder,
1874 offset + 0,
1875 _depth
1876 )?;
1877 fidl::decode!(
1878 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1879 D,
1880 &mut self.tx_power_level,
1881 decoder,
1882 offset + 16,
1883 _depth
1884 )?;
1885 fidl::decode!(
1886 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1887 D,
1888 &mut self.appearance,
1889 decoder,
1890 offset + 24,
1891 _depth
1892 )?;
1893 fidl::decode!(
1894 fidl::encoding::Optional<
1895 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1896 >,
1897 D,
1898 &mut self.service_uuids,
1899 decoder,
1900 offset + 32,
1901 _depth
1902 )?;
1903 fidl::decode!(
1904 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1905 D,
1906 &mut self.service_data,
1907 decoder,
1908 offset + 48,
1909 _depth
1910 )?;
1911 fidl::decode!(
1912 fidl::encoding::Optional<
1913 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1914 >,
1915 D,
1916 &mut self.manufacturer_specific_data,
1917 decoder,
1918 offset + 64,
1919 _depth
1920 )?;
1921 fidl::decode!(
1922 fidl::encoding::Optional<
1923 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1924 >,
1925 D,
1926 &mut self.solicited_service_uuids,
1927 decoder,
1928 offset + 80,
1929 _depth
1930 )?;
1931 fidl::decode!(
1932 fidl::encoding::Optional<
1933 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1934 >,
1935 D,
1936 &mut self.uris,
1937 decoder,
1938 offset + 96,
1939 _depth
1940 )?;
1941 Ok(())
1942 }
1943 }
1944
1945 impl fidl::encoding::ValueTypeMarker for CentralConnectPeripheralResponse {
1946 type Borrowed<'a> = &'a Self;
1947 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1948 value
1949 }
1950 }
1951
1952 unsafe impl fidl::encoding::TypeMarker for CentralConnectPeripheralResponse {
1953 type Owned = Self;
1954
1955 #[inline(always)]
1956 fn inline_align(_context: fidl::encoding::Context) -> usize {
1957 8
1958 }
1959
1960 #[inline(always)]
1961 fn inline_size(_context: fidl::encoding::Context) -> usize {
1962 8
1963 }
1964 }
1965
1966 unsafe impl<D: fidl::encoding::ResourceDialect>
1967 fidl::encoding::Encode<CentralConnectPeripheralResponse, D>
1968 for &CentralConnectPeripheralResponse
1969 {
1970 #[inline]
1971 unsafe fn encode(
1972 self,
1973 encoder: &mut fidl::encoding::Encoder<'_, D>,
1974 offset: usize,
1975 _depth: fidl::encoding::Depth,
1976 ) -> fidl::Result<()> {
1977 encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
1978 fidl::encoding::Encode::<CentralConnectPeripheralResponse, D>::encode(
1980 (
1981 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1982 ),
1983 encoder, offset, _depth
1984 )
1985 }
1986 }
1987 unsafe impl<
1988 D: fidl::encoding::ResourceDialect,
1989 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
1990 > fidl::encoding::Encode<CentralConnectPeripheralResponse, D> for (T0,)
1991 {
1992 #[inline]
1993 unsafe fn encode(
1994 self,
1995 encoder: &mut fidl::encoding::Encoder<'_, D>,
1996 offset: usize,
1997 depth: fidl::encoding::Depth,
1998 ) -> fidl::Result<()> {
1999 encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2000 self.0.encode(encoder, offset + 0, depth)?;
2004 Ok(())
2005 }
2006 }
2007
2008 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2009 for CentralConnectPeripheralResponse
2010 {
2011 #[inline(always)]
2012 fn new_empty() -> Self {
2013 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2014 }
2015
2016 #[inline]
2017 unsafe fn decode(
2018 &mut self,
2019 decoder: &mut fidl::encoding::Decoder<'_, D>,
2020 offset: usize,
2021 _depth: fidl::encoding::Depth,
2022 ) -> fidl::Result<()> {
2023 decoder.debug_check_bounds::<Self>(offset);
2024 fidl::decode!(
2026 fidl_fuchsia_bluetooth__common::Status,
2027 D,
2028 &mut self.status,
2029 decoder,
2030 offset + 0,
2031 _depth
2032 )?;
2033 Ok(())
2034 }
2035 }
2036
2037 impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralRequest {
2038 type Borrowed<'a> = &'a Self;
2039 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2040 value
2041 }
2042 }
2043
2044 unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralRequest {
2045 type Owned = Self;
2046
2047 #[inline(always)]
2048 fn inline_align(_context: fidl::encoding::Context) -> usize {
2049 8
2050 }
2051
2052 #[inline(always)]
2053 fn inline_size(_context: fidl::encoding::Context) -> usize {
2054 16
2055 }
2056 }
2057
2058 unsafe impl<D: fidl::encoding::ResourceDialect>
2059 fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D>
2060 for &CentralDisconnectPeripheralRequest
2061 {
2062 #[inline]
2063 unsafe fn encode(
2064 self,
2065 encoder: &mut fidl::encoding::Encoder<'_, D>,
2066 offset: usize,
2067 _depth: fidl::encoding::Depth,
2068 ) -> fidl::Result<()> {
2069 encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2070 fidl::encoding::Encode::<CentralDisconnectPeripheralRequest, D>::encode(
2072 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2073 &self.identifier,
2074 ),),
2075 encoder,
2076 offset,
2077 _depth,
2078 )
2079 }
2080 }
2081 unsafe impl<
2082 D: fidl::encoding::ResourceDialect,
2083 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2084 > fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D> for (T0,)
2085 {
2086 #[inline]
2087 unsafe fn encode(
2088 self,
2089 encoder: &mut fidl::encoding::Encoder<'_, D>,
2090 offset: usize,
2091 depth: fidl::encoding::Depth,
2092 ) -> fidl::Result<()> {
2093 encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2094 self.0.encode(encoder, offset + 0, depth)?;
2098 Ok(())
2099 }
2100 }
2101
2102 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2103 for CentralDisconnectPeripheralRequest
2104 {
2105 #[inline(always)]
2106 fn new_empty() -> Self {
2107 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2108 }
2109
2110 #[inline]
2111 unsafe fn decode(
2112 &mut self,
2113 decoder: &mut fidl::encoding::Decoder<'_, D>,
2114 offset: usize,
2115 _depth: fidl::encoding::Depth,
2116 ) -> fidl::Result<()> {
2117 decoder.debug_check_bounds::<Self>(offset);
2118 fidl::decode!(
2120 fidl::encoding::BoundedString<16>,
2121 D,
2122 &mut self.identifier,
2123 decoder,
2124 offset + 0,
2125 _depth
2126 )?;
2127 Ok(())
2128 }
2129 }
2130
2131 impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralResponse {
2132 type Borrowed<'a> = &'a Self;
2133 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2134 value
2135 }
2136 }
2137
2138 unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralResponse {
2139 type Owned = Self;
2140
2141 #[inline(always)]
2142 fn inline_align(_context: fidl::encoding::Context) -> usize {
2143 8
2144 }
2145
2146 #[inline(always)]
2147 fn inline_size(_context: fidl::encoding::Context) -> usize {
2148 8
2149 }
2150 }
2151
2152 unsafe impl<D: fidl::encoding::ResourceDialect>
2153 fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D>
2154 for &CentralDisconnectPeripheralResponse
2155 {
2156 #[inline]
2157 unsafe fn encode(
2158 self,
2159 encoder: &mut fidl::encoding::Encoder<'_, D>,
2160 offset: usize,
2161 _depth: fidl::encoding::Depth,
2162 ) -> fidl::Result<()> {
2163 encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2164 fidl::encoding::Encode::<CentralDisconnectPeripheralResponse, D>::encode(
2166 (
2167 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2168 ),
2169 encoder, offset, _depth
2170 )
2171 }
2172 }
2173 unsafe impl<
2174 D: fidl::encoding::ResourceDialect,
2175 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2176 > fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D> for (T0,)
2177 {
2178 #[inline]
2179 unsafe fn encode(
2180 self,
2181 encoder: &mut fidl::encoding::Encoder<'_, D>,
2182 offset: usize,
2183 depth: fidl::encoding::Depth,
2184 ) -> fidl::Result<()> {
2185 encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2186 self.0.encode(encoder, offset + 0, depth)?;
2190 Ok(())
2191 }
2192 }
2193
2194 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2195 for CentralDisconnectPeripheralResponse
2196 {
2197 #[inline(always)]
2198 fn new_empty() -> Self {
2199 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2200 }
2201
2202 #[inline]
2203 unsafe fn decode(
2204 &mut self,
2205 decoder: &mut fidl::encoding::Decoder<'_, D>,
2206 offset: usize,
2207 _depth: fidl::encoding::Depth,
2208 ) -> fidl::Result<()> {
2209 decoder.debug_check_bounds::<Self>(offset);
2210 fidl::decode!(
2212 fidl_fuchsia_bluetooth__common::Status,
2213 D,
2214 &mut self.status,
2215 decoder,
2216 offset + 0,
2217 _depth
2218 )?;
2219 Ok(())
2220 }
2221 }
2222
2223 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralRequest {
2224 type Borrowed<'a> = &'a Self;
2225 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2226 value
2227 }
2228 }
2229
2230 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralRequest {
2231 type Owned = Self;
2232
2233 #[inline(always)]
2234 fn inline_align(_context: fidl::encoding::Context) -> usize {
2235 8
2236 }
2237
2238 #[inline(always)]
2239 fn inline_size(_context: fidl::encoding::Context) -> usize {
2240 16
2241 }
2242 }
2243
2244 unsafe impl<D: fidl::encoding::ResourceDialect>
2245 fidl::encoding::Encode<CentralGetPeripheralRequest, D> for &CentralGetPeripheralRequest
2246 {
2247 #[inline]
2248 unsafe fn encode(
2249 self,
2250 encoder: &mut fidl::encoding::Encoder<'_, D>,
2251 offset: usize,
2252 _depth: fidl::encoding::Depth,
2253 ) -> fidl::Result<()> {
2254 encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2255 fidl::encoding::Encode::<CentralGetPeripheralRequest, D>::encode(
2257 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2258 &self.identifier,
2259 ),),
2260 encoder,
2261 offset,
2262 _depth,
2263 )
2264 }
2265 }
2266 unsafe impl<
2267 D: fidl::encoding::ResourceDialect,
2268 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2269 > fidl::encoding::Encode<CentralGetPeripheralRequest, D> for (T0,)
2270 {
2271 #[inline]
2272 unsafe fn encode(
2273 self,
2274 encoder: &mut fidl::encoding::Encoder<'_, D>,
2275 offset: usize,
2276 depth: fidl::encoding::Depth,
2277 ) -> fidl::Result<()> {
2278 encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2279 self.0.encode(encoder, offset + 0, depth)?;
2283 Ok(())
2284 }
2285 }
2286
2287 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2288 for CentralGetPeripheralRequest
2289 {
2290 #[inline(always)]
2291 fn new_empty() -> Self {
2292 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2293 }
2294
2295 #[inline]
2296 unsafe fn decode(
2297 &mut self,
2298 decoder: &mut fidl::encoding::Decoder<'_, D>,
2299 offset: usize,
2300 _depth: fidl::encoding::Depth,
2301 ) -> fidl::Result<()> {
2302 decoder.debug_check_bounds::<Self>(offset);
2303 fidl::decode!(
2305 fidl::encoding::BoundedString<16>,
2306 D,
2307 &mut self.identifier,
2308 decoder,
2309 offset + 0,
2310 _depth
2311 )?;
2312 Ok(())
2313 }
2314 }
2315
2316 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralResponse {
2317 type Borrowed<'a> = &'a Self;
2318 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2319 value
2320 }
2321 }
2322
2323 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralResponse {
2324 type Owned = Self;
2325
2326 #[inline(always)]
2327 fn inline_align(_context: fidl::encoding::Context) -> usize {
2328 8
2329 }
2330
2331 #[inline(always)]
2332 fn inline_size(_context: fidl::encoding::Context) -> usize {
2333 8
2334 }
2335 }
2336
2337 unsafe impl<D: fidl::encoding::ResourceDialect>
2338 fidl::encoding::Encode<CentralGetPeripheralResponse, D> for &CentralGetPeripheralResponse
2339 {
2340 #[inline]
2341 unsafe fn encode(
2342 self,
2343 encoder: &mut fidl::encoding::Encoder<'_, D>,
2344 offset: usize,
2345 _depth: fidl::encoding::Depth,
2346 ) -> fidl::Result<()> {
2347 encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2348 fidl::encoding::Encode::<CentralGetPeripheralResponse, D>::encode(
2350 (<fidl::encoding::Boxed<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(
2351 &self.peripheral,
2352 ),),
2353 encoder,
2354 offset,
2355 _depth,
2356 )
2357 }
2358 }
2359 unsafe impl<
2360 D: fidl::encoding::ResourceDialect,
2361 T0: fidl::encoding::Encode<fidl::encoding::Boxed<RemoteDevice>, D>,
2362 > fidl::encoding::Encode<CentralGetPeripheralResponse, D> for (T0,)
2363 {
2364 #[inline]
2365 unsafe fn encode(
2366 self,
2367 encoder: &mut fidl::encoding::Encoder<'_, D>,
2368 offset: usize,
2369 depth: fidl::encoding::Depth,
2370 ) -> fidl::Result<()> {
2371 encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2372 self.0.encode(encoder, offset + 0, depth)?;
2376 Ok(())
2377 }
2378 }
2379
2380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2381 for CentralGetPeripheralResponse
2382 {
2383 #[inline(always)]
2384 fn new_empty() -> Self {
2385 Self { peripheral: fidl::new_empty!(fidl::encoding::Boxed<RemoteDevice>, D) }
2386 }
2387
2388 #[inline]
2389 unsafe fn decode(
2390 &mut self,
2391 decoder: &mut fidl::encoding::Decoder<'_, D>,
2392 offset: usize,
2393 _depth: fidl::encoding::Depth,
2394 ) -> fidl::Result<()> {
2395 decoder.debug_check_bounds::<Self>(offset);
2396 fidl::decode!(
2398 fidl::encoding::Boxed<RemoteDevice>,
2399 D,
2400 &mut self.peripheral,
2401 decoder,
2402 offset + 0,
2403 _depth
2404 )?;
2405 Ok(())
2406 }
2407 }
2408
2409 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsRequest {
2410 type Borrowed<'a> = &'a Self;
2411 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2412 value
2413 }
2414 }
2415
2416 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsRequest {
2417 type Owned = Self;
2418
2419 #[inline(always)]
2420 fn inline_align(_context: fidl::encoding::Context) -> usize {
2421 8
2422 }
2423
2424 #[inline(always)]
2425 fn inline_size(_context: fidl::encoding::Context) -> usize {
2426 16
2427 }
2428 }
2429
2430 unsafe impl<D: fidl::encoding::ResourceDialect>
2431 fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for &CentralGetPeripheralsRequest
2432 {
2433 #[inline]
2434 unsafe fn encode(
2435 self,
2436 encoder: &mut fidl::encoding::Encoder<'_, D>,
2437 offset: usize,
2438 _depth: fidl::encoding::Depth,
2439 ) -> fidl::Result<()> {
2440 encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2441 fidl::encoding::Encode::<CentralGetPeripheralsRequest, D>::encode(
2443 (<fidl::encoding::Optional<
2444 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2445 > as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),),
2446 encoder,
2447 offset,
2448 _depth,
2449 )
2450 }
2451 }
2452 unsafe impl<
2453 D: fidl::encoding::ResourceDialect,
2454 T0: fidl::encoding::Encode<
2455 fidl::encoding::Optional<
2456 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2457 >,
2458 D,
2459 >,
2460 > fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for (T0,)
2461 {
2462 #[inline]
2463 unsafe fn encode(
2464 self,
2465 encoder: &mut fidl::encoding::Encoder<'_, D>,
2466 offset: usize,
2467 depth: fidl::encoding::Depth,
2468 ) -> fidl::Result<()> {
2469 encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2470 self.0.encode(encoder, offset + 0, depth)?;
2474 Ok(())
2475 }
2476 }
2477
2478 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2479 for CentralGetPeripheralsRequest
2480 {
2481 #[inline(always)]
2482 fn new_empty() -> Self {
2483 Self {
2484 service_uuids: fidl::new_empty!(
2485 fidl::encoding::Optional<
2486 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2487 >,
2488 D
2489 ),
2490 }
2491 }
2492
2493 #[inline]
2494 unsafe fn decode(
2495 &mut self,
2496 decoder: &mut fidl::encoding::Decoder<'_, D>,
2497 offset: usize,
2498 _depth: fidl::encoding::Depth,
2499 ) -> fidl::Result<()> {
2500 decoder.debug_check_bounds::<Self>(offset);
2501 fidl::decode!(
2503 fidl::encoding::Optional<
2504 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2505 >,
2506 D,
2507 &mut self.service_uuids,
2508 decoder,
2509 offset + 0,
2510 _depth
2511 )?;
2512 Ok(())
2513 }
2514 }
2515
2516 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsResponse {
2517 type Borrowed<'a> = &'a Self;
2518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2519 value
2520 }
2521 }
2522
2523 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsResponse {
2524 type Owned = Self;
2525
2526 #[inline(always)]
2527 fn inline_align(_context: fidl::encoding::Context) -> usize {
2528 8
2529 }
2530
2531 #[inline(always)]
2532 fn inline_size(_context: fidl::encoding::Context) -> usize {
2533 16
2534 }
2535 }
2536
2537 unsafe impl<D: fidl::encoding::ResourceDialect>
2538 fidl::encoding::Encode<CentralGetPeripheralsResponse, D>
2539 for &CentralGetPeripheralsResponse
2540 {
2541 #[inline]
2542 unsafe fn encode(
2543 self,
2544 encoder: &mut fidl::encoding::Encoder<'_, D>,
2545 offset: usize,
2546 _depth: fidl::encoding::Depth,
2547 ) -> fidl::Result<()> {
2548 encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2549 fidl::encoding::Encode::<CentralGetPeripheralsResponse, D>::encode(
2551 (
2552 <fidl::encoding::UnboundedVector<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(&self.peripherals),
2553 ),
2554 encoder, offset, _depth
2555 )
2556 }
2557 }
2558 unsafe impl<
2559 D: fidl::encoding::ResourceDialect,
2560 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RemoteDevice>, D>,
2561 > fidl::encoding::Encode<CentralGetPeripheralsResponse, D> for (T0,)
2562 {
2563 #[inline]
2564 unsafe fn encode(
2565 self,
2566 encoder: &mut fidl::encoding::Encoder<'_, D>,
2567 offset: usize,
2568 depth: fidl::encoding::Depth,
2569 ) -> fidl::Result<()> {
2570 encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2571 self.0.encode(encoder, offset + 0, depth)?;
2575 Ok(())
2576 }
2577 }
2578
2579 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2580 for CentralGetPeripheralsResponse
2581 {
2582 #[inline(always)]
2583 fn new_empty() -> Self {
2584 Self { peripherals: fidl::new_empty!(fidl::encoding::UnboundedVector<RemoteDevice>, D) }
2585 }
2586
2587 #[inline]
2588 unsafe fn decode(
2589 &mut self,
2590 decoder: &mut fidl::encoding::Decoder<'_, D>,
2591 offset: usize,
2592 _depth: fidl::encoding::Depth,
2593 ) -> fidl::Result<()> {
2594 decoder.debug_check_bounds::<Self>(offset);
2595 fidl::decode!(
2597 fidl::encoding::UnboundedVector<RemoteDevice>,
2598 D,
2599 &mut self.peripherals,
2600 decoder,
2601 offset + 0,
2602 _depth
2603 )?;
2604 Ok(())
2605 }
2606 }
2607
2608 impl fidl::encoding::ValueTypeMarker for CentralOnDeviceDiscoveredRequest {
2609 type Borrowed<'a> = &'a Self;
2610 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2611 value
2612 }
2613 }
2614
2615 unsafe impl fidl::encoding::TypeMarker for CentralOnDeviceDiscoveredRequest {
2616 type Owned = Self;
2617
2618 #[inline(always)]
2619 fn inline_align(_context: fidl::encoding::Context) -> usize {
2620 8
2621 }
2622
2623 #[inline(always)]
2624 fn inline_size(_context: fidl::encoding::Context) -> usize {
2625 40
2626 }
2627 }
2628
2629 unsafe impl<D: fidl::encoding::ResourceDialect>
2630 fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D>
2631 for &CentralOnDeviceDiscoveredRequest
2632 {
2633 #[inline]
2634 unsafe fn encode(
2635 self,
2636 encoder: &mut fidl::encoding::Encoder<'_, D>,
2637 offset: usize,
2638 _depth: fidl::encoding::Depth,
2639 ) -> fidl::Result<()> {
2640 encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2641 fidl::encoding::Encode::<CentralOnDeviceDiscoveredRequest, D>::encode(
2643 (<RemoteDevice as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
2644 encoder,
2645 offset,
2646 _depth,
2647 )
2648 }
2649 }
2650 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RemoteDevice, D>>
2651 fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D> for (T0,)
2652 {
2653 #[inline]
2654 unsafe fn encode(
2655 self,
2656 encoder: &mut fidl::encoding::Encoder<'_, D>,
2657 offset: usize,
2658 depth: fidl::encoding::Depth,
2659 ) -> fidl::Result<()> {
2660 encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2661 self.0.encode(encoder, offset + 0, depth)?;
2665 Ok(())
2666 }
2667 }
2668
2669 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2670 for CentralOnDeviceDiscoveredRequest
2671 {
2672 #[inline(always)]
2673 fn new_empty() -> Self {
2674 Self { device: fidl::new_empty!(RemoteDevice, D) }
2675 }
2676
2677 #[inline]
2678 unsafe fn decode(
2679 &mut self,
2680 decoder: &mut fidl::encoding::Decoder<'_, D>,
2681 offset: usize,
2682 _depth: fidl::encoding::Depth,
2683 ) -> fidl::Result<()> {
2684 decoder.debug_check_bounds::<Self>(offset);
2685 fidl::decode!(RemoteDevice, D, &mut self.device, decoder, offset + 0, _depth)?;
2687 Ok(())
2688 }
2689 }
2690
2691 impl fidl::encoding::ValueTypeMarker for CentralOnPeripheralDisconnectedRequest {
2692 type Borrowed<'a> = &'a Self;
2693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2694 value
2695 }
2696 }
2697
2698 unsafe impl fidl::encoding::TypeMarker for CentralOnPeripheralDisconnectedRequest {
2699 type Owned = Self;
2700
2701 #[inline(always)]
2702 fn inline_align(_context: fidl::encoding::Context) -> usize {
2703 8
2704 }
2705
2706 #[inline(always)]
2707 fn inline_size(_context: fidl::encoding::Context) -> usize {
2708 16
2709 }
2710 }
2711
2712 unsafe impl<D: fidl::encoding::ResourceDialect>
2713 fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D>
2714 for &CentralOnPeripheralDisconnectedRequest
2715 {
2716 #[inline]
2717 unsafe fn encode(
2718 self,
2719 encoder: &mut fidl::encoding::Encoder<'_, D>,
2720 offset: usize,
2721 _depth: fidl::encoding::Depth,
2722 ) -> fidl::Result<()> {
2723 encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2724 fidl::encoding::Encode::<CentralOnPeripheralDisconnectedRequest, D>::encode(
2726 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2727 &self.identifier,
2728 ),),
2729 encoder,
2730 offset,
2731 _depth,
2732 )
2733 }
2734 }
2735 unsafe impl<
2736 D: fidl::encoding::ResourceDialect,
2737 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2738 > fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D> for (T0,)
2739 {
2740 #[inline]
2741 unsafe fn encode(
2742 self,
2743 encoder: &mut fidl::encoding::Encoder<'_, D>,
2744 offset: usize,
2745 depth: fidl::encoding::Depth,
2746 ) -> fidl::Result<()> {
2747 encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2748 self.0.encode(encoder, offset + 0, depth)?;
2752 Ok(())
2753 }
2754 }
2755
2756 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2757 for CentralOnPeripheralDisconnectedRequest
2758 {
2759 #[inline(always)]
2760 fn new_empty() -> Self {
2761 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2762 }
2763
2764 #[inline]
2765 unsafe fn decode(
2766 &mut self,
2767 decoder: &mut fidl::encoding::Decoder<'_, D>,
2768 offset: usize,
2769 _depth: fidl::encoding::Depth,
2770 ) -> fidl::Result<()> {
2771 decoder.debug_check_bounds::<Self>(offset);
2772 fidl::decode!(
2774 fidl::encoding::BoundedString<16>,
2775 D,
2776 &mut self.identifier,
2777 decoder,
2778 offset + 0,
2779 _depth
2780 )?;
2781 Ok(())
2782 }
2783 }
2784
2785 impl fidl::encoding::ValueTypeMarker for CentralOnScanStateChangedRequest {
2786 type Borrowed<'a> = &'a Self;
2787 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2788 value
2789 }
2790 }
2791
2792 unsafe impl fidl::encoding::TypeMarker for CentralOnScanStateChangedRequest {
2793 type Owned = Self;
2794
2795 #[inline(always)]
2796 fn inline_align(_context: fidl::encoding::Context) -> usize {
2797 1
2798 }
2799
2800 #[inline(always)]
2801 fn inline_size(_context: fidl::encoding::Context) -> usize {
2802 1
2803 }
2804 }
2805
2806 unsafe impl<D: fidl::encoding::ResourceDialect>
2807 fidl::encoding::Encode<CentralOnScanStateChangedRequest, D>
2808 for &CentralOnScanStateChangedRequest
2809 {
2810 #[inline]
2811 unsafe fn encode(
2812 self,
2813 encoder: &mut fidl::encoding::Encoder<'_, D>,
2814 offset: usize,
2815 _depth: fidl::encoding::Depth,
2816 ) -> fidl::Result<()> {
2817 encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2818 fidl::encoding::Encode::<CentralOnScanStateChangedRequest, D>::encode(
2820 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.scanning),),
2821 encoder,
2822 offset,
2823 _depth,
2824 )
2825 }
2826 }
2827 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2828 fidl::encoding::Encode<CentralOnScanStateChangedRequest, D> for (T0,)
2829 {
2830 #[inline]
2831 unsafe fn encode(
2832 self,
2833 encoder: &mut fidl::encoding::Encoder<'_, D>,
2834 offset: usize,
2835 depth: fidl::encoding::Depth,
2836 ) -> fidl::Result<()> {
2837 encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2838 self.0.encode(encoder, offset + 0, depth)?;
2842 Ok(())
2843 }
2844 }
2845
2846 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2847 for CentralOnScanStateChangedRequest
2848 {
2849 #[inline(always)]
2850 fn new_empty() -> Self {
2851 Self { scanning: fidl::new_empty!(bool, D) }
2852 }
2853
2854 #[inline]
2855 unsafe fn decode(
2856 &mut self,
2857 decoder: &mut fidl::encoding::Decoder<'_, D>,
2858 offset: usize,
2859 _depth: fidl::encoding::Depth,
2860 ) -> fidl::Result<()> {
2861 decoder.debug_check_bounds::<Self>(offset);
2862 fidl::decode!(bool, D, &mut self.scanning, decoder, offset + 0, _depth)?;
2864 Ok(())
2865 }
2866 }
2867
2868 impl fidl::encoding::ValueTypeMarker for CentralStartScanRequest {
2869 type Borrowed<'a> = &'a Self;
2870 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2871 value
2872 }
2873 }
2874
2875 unsafe impl fidl::encoding::TypeMarker for CentralStartScanRequest {
2876 type Owned = Self;
2877
2878 #[inline(always)]
2879 fn inline_align(_context: fidl::encoding::Context) -> usize {
2880 8
2881 }
2882
2883 #[inline(always)]
2884 fn inline_size(_context: fidl::encoding::Context) -> usize {
2885 8
2886 }
2887 }
2888
2889 unsafe impl<D: fidl::encoding::ResourceDialect>
2890 fidl::encoding::Encode<CentralStartScanRequest, D> for &CentralStartScanRequest
2891 {
2892 #[inline]
2893 unsafe fn encode(
2894 self,
2895 encoder: &mut fidl::encoding::Encoder<'_, D>,
2896 offset: usize,
2897 _depth: fidl::encoding::Depth,
2898 ) -> fidl::Result<()> {
2899 encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2900 fidl::encoding::Encode::<CentralStartScanRequest, D>::encode(
2902 (<fidl::encoding::Boxed<ScanFilter> as fidl::encoding::ValueTypeMarker>::borrow(
2903 &self.filter,
2904 ),),
2905 encoder,
2906 offset,
2907 _depth,
2908 )
2909 }
2910 }
2911 unsafe impl<
2912 D: fidl::encoding::ResourceDialect,
2913 T0: fidl::encoding::Encode<fidl::encoding::Boxed<ScanFilter>, D>,
2914 > fidl::encoding::Encode<CentralStartScanRequest, D> for (T0,)
2915 {
2916 #[inline]
2917 unsafe fn encode(
2918 self,
2919 encoder: &mut fidl::encoding::Encoder<'_, D>,
2920 offset: usize,
2921 depth: fidl::encoding::Depth,
2922 ) -> fidl::Result<()> {
2923 encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2924 self.0.encode(encoder, offset + 0, depth)?;
2928 Ok(())
2929 }
2930 }
2931
2932 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2933 for CentralStartScanRequest
2934 {
2935 #[inline(always)]
2936 fn new_empty() -> Self {
2937 Self { filter: fidl::new_empty!(fidl::encoding::Boxed<ScanFilter>, D) }
2938 }
2939
2940 #[inline]
2941 unsafe fn decode(
2942 &mut self,
2943 decoder: &mut fidl::encoding::Decoder<'_, D>,
2944 offset: usize,
2945 _depth: fidl::encoding::Depth,
2946 ) -> fidl::Result<()> {
2947 decoder.debug_check_bounds::<Self>(offset);
2948 fidl::decode!(
2950 fidl::encoding::Boxed<ScanFilter>,
2951 D,
2952 &mut self.filter,
2953 decoder,
2954 offset + 0,
2955 _depth
2956 )?;
2957 Ok(())
2958 }
2959 }
2960
2961 impl fidl::encoding::ValueTypeMarker for CentralStartScanResponse {
2962 type Borrowed<'a> = &'a Self;
2963 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2964 value
2965 }
2966 }
2967
2968 unsafe impl fidl::encoding::TypeMarker for CentralStartScanResponse {
2969 type Owned = Self;
2970
2971 #[inline(always)]
2972 fn inline_align(_context: fidl::encoding::Context) -> usize {
2973 8
2974 }
2975
2976 #[inline(always)]
2977 fn inline_size(_context: fidl::encoding::Context) -> usize {
2978 8
2979 }
2980 }
2981
2982 unsafe impl<D: fidl::encoding::ResourceDialect>
2983 fidl::encoding::Encode<CentralStartScanResponse, D> for &CentralStartScanResponse
2984 {
2985 #[inline]
2986 unsafe fn encode(
2987 self,
2988 encoder: &mut fidl::encoding::Encoder<'_, D>,
2989 offset: usize,
2990 _depth: fidl::encoding::Depth,
2991 ) -> fidl::Result<()> {
2992 encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
2993 fidl::encoding::Encode::<CentralStartScanResponse, D>::encode(
2995 (
2996 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2997 ),
2998 encoder, offset, _depth
2999 )
3000 }
3001 }
3002 unsafe impl<
3003 D: fidl::encoding::ResourceDialect,
3004 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
3005 > fidl::encoding::Encode<CentralStartScanResponse, D> for (T0,)
3006 {
3007 #[inline]
3008 unsafe fn encode(
3009 self,
3010 encoder: &mut fidl::encoding::Encoder<'_, D>,
3011 offset: usize,
3012 depth: fidl::encoding::Depth,
3013 ) -> fidl::Result<()> {
3014 encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3015 self.0.encode(encoder, offset + 0, depth)?;
3019 Ok(())
3020 }
3021 }
3022
3023 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3024 for CentralStartScanResponse
3025 {
3026 #[inline(always)]
3027 fn new_empty() -> Self {
3028 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
3029 }
3030
3031 #[inline]
3032 unsafe fn decode(
3033 &mut self,
3034 decoder: &mut fidl::encoding::Decoder<'_, D>,
3035 offset: usize,
3036 _depth: fidl::encoding::Depth,
3037 ) -> fidl::Result<()> {
3038 decoder.debug_check_bounds::<Self>(offset);
3039 fidl::decode!(
3041 fidl_fuchsia_bluetooth__common::Status,
3042 D,
3043 &mut self.status,
3044 decoder,
3045 offset + 0,
3046 _depth
3047 )?;
3048 Ok(())
3049 }
3050 }
3051
3052 impl fidl::encoding::ValueTypeMarker for ManufacturerData {
3053 type Borrowed<'a> = &'a Self;
3054 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3055 value
3056 }
3057 }
3058
3059 unsafe impl fidl::encoding::TypeMarker for ManufacturerData {
3060 type Owned = Self;
3061
3062 #[inline(always)]
3063 fn inline_align(_context: fidl::encoding::Context) -> usize {
3064 8
3065 }
3066
3067 #[inline(always)]
3068 fn inline_size(_context: fidl::encoding::Context) -> usize {
3069 24
3070 }
3071 }
3072
3073 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManufacturerData, D>
3074 for &ManufacturerData
3075 {
3076 #[inline]
3077 unsafe fn encode(
3078 self,
3079 encoder: &mut fidl::encoding::Encoder<'_, D>,
3080 offset: usize,
3081 _depth: fidl::encoding::Depth,
3082 ) -> fidl::Result<()> {
3083 encoder.debug_check_bounds::<ManufacturerData>(offset);
3084 fidl::encoding::Encode::<ManufacturerData, D>::encode(
3086 (
3087 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3088 <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(
3089 &self.data,
3090 ),
3091 ),
3092 encoder,
3093 offset,
3094 _depth,
3095 )
3096 }
3097 }
3098 unsafe impl<
3099 D: fidl::encoding::ResourceDialect,
3100 T0: fidl::encoding::Encode<u16, D>,
3101 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3102 > fidl::encoding::Encode<ManufacturerData, D> for (T0, T1)
3103 {
3104 #[inline]
3105 unsafe fn encode(
3106 self,
3107 encoder: &mut fidl::encoding::Encoder<'_, D>,
3108 offset: usize,
3109 depth: fidl::encoding::Depth,
3110 ) -> fidl::Result<()> {
3111 encoder.debug_check_bounds::<ManufacturerData>(offset);
3112 unsafe {
3115 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3116 (ptr as *mut u64).write_unaligned(0);
3117 }
3118 self.0.encode(encoder, offset + 0, depth)?;
3120 self.1.encode(encoder, offset + 8, depth)?;
3121 Ok(())
3122 }
3123 }
3124
3125 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManufacturerData {
3126 #[inline(always)]
3127 fn new_empty() -> Self {
3128 Self {
3129 company_id: fidl::new_empty!(u16, D),
3130 data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3131 }
3132 }
3133
3134 #[inline]
3135 unsafe fn decode(
3136 &mut self,
3137 decoder: &mut fidl::encoding::Decoder<'_, D>,
3138 offset: usize,
3139 _depth: fidl::encoding::Depth,
3140 ) -> fidl::Result<()> {
3141 decoder.debug_check_bounds::<Self>(offset);
3142 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3144 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3145 let mask = 0xffffffffffff0000u64;
3146 let maskedval = padval & mask;
3147 if maskedval != 0 {
3148 return Err(fidl::Error::NonZeroPadding {
3149 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3150 });
3151 }
3152 fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3153 fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 8, _depth)?;
3154 Ok(())
3155 }
3156 }
3157
3158 impl fidl::encoding::ValueTypeMarker for ManufacturerSpecificDataEntry {
3159 type Borrowed<'a> = &'a Self;
3160 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3161 value
3162 }
3163 }
3164
3165 unsafe impl fidl::encoding::TypeMarker for ManufacturerSpecificDataEntry {
3166 type Owned = Self;
3167
3168 #[inline(always)]
3169 fn inline_align(_context: fidl::encoding::Context) -> usize {
3170 8
3171 }
3172
3173 #[inline(always)]
3174 fn inline_size(_context: fidl::encoding::Context) -> usize {
3175 24
3176 }
3177 }
3178
3179 unsafe impl<D: fidl::encoding::ResourceDialect>
3180 fidl::encoding::Encode<ManufacturerSpecificDataEntry, D>
3181 for &ManufacturerSpecificDataEntry
3182 {
3183 #[inline]
3184 unsafe fn encode(
3185 self,
3186 encoder: &mut fidl::encoding::Encoder<'_, D>,
3187 offset: usize,
3188 _depth: fidl::encoding::Depth,
3189 ) -> fidl::Result<()> {
3190 encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3191 fidl::encoding::Encode::<ManufacturerSpecificDataEntry, D>::encode(
3193 (
3194 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3195 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3196 ),
3197 encoder, offset, _depth
3198 )
3199 }
3200 }
3201 unsafe impl<
3202 D: fidl::encoding::ResourceDialect,
3203 T0: fidl::encoding::Encode<u16, D>,
3204 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3205 > fidl::encoding::Encode<ManufacturerSpecificDataEntry, D> for (T0, T1)
3206 {
3207 #[inline]
3208 unsafe fn encode(
3209 self,
3210 encoder: &mut fidl::encoding::Encoder<'_, D>,
3211 offset: usize,
3212 depth: fidl::encoding::Depth,
3213 ) -> fidl::Result<()> {
3214 encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3215 unsafe {
3218 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3219 (ptr as *mut u64).write_unaligned(0);
3220 }
3221 self.0.encode(encoder, offset + 0, depth)?;
3223 self.1.encode(encoder, offset + 8, depth)?;
3224 Ok(())
3225 }
3226 }
3227
3228 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3229 for ManufacturerSpecificDataEntry
3230 {
3231 #[inline(always)]
3232 fn new_empty() -> Self {
3233 Self {
3234 company_id: fidl::new_empty!(u16, D),
3235 data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3236 }
3237 }
3238
3239 #[inline]
3240 unsafe fn decode(
3241 &mut self,
3242 decoder: &mut fidl::encoding::Decoder<'_, D>,
3243 offset: usize,
3244 _depth: fidl::encoding::Depth,
3245 ) -> fidl::Result<()> {
3246 decoder.debug_check_bounds::<Self>(offset);
3247 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3249 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3250 let mask = 0xffffffffffff0000u64;
3251 let maskedval = padval & mask;
3252 if maskedval != 0 {
3253 return Err(fidl::Error::NonZeroPadding {
3254 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3255 });
3256 }
3257 fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3258 fidl::decode!(
3259 fidl::encoding::UnboundedVector<u8>,
3260 D,
3261 &mut self.data,
3262 decoder,
3263 offset + 8,
3264 _depth
3265 )?;
3266 Ok(())
3267 }
3268 }
3269
3270 impl fidl::encoding::ValueTypeMarker for RemoteDevice {
3271 type Borrowed<'a> = &'a Self;
3272 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3273 value
3274 }
3275 }
3276
3277 unsafe impl fidl::encoding::TypeMarker for RemoteDevice {
3278 type Owned = Self;
3279
3280 #[inline(always)]
3281 fn inline_align(_context: fidl::encoding::Context) -> usize {
3282 8
3283 }
3284
3285 #[inline(always)]
3286 fn inline_size(_context: fidl::encoding::Context) -> usize {
3287 40
3288 }
3289 }
3290
3291 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RemoteDevice, D>
3292 for &RemoteDevice
3293 {
3294 #[inline]
3295 unsafe fn encode(
3296 self,
3297 encoder: &mut fidl::encoding::Encoder<'_, D>,
3298 offset: usize,
3299 _depth: fidl::encoding::Depth,
3300 ) -> fidl::Result<()> {
3301 encoder.debug_check_bounds::<RemoteDevice>(offset);
3302 fidl::encoding::Encode::<RemoteDevice, D>::encode(
3304 (
3305 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(&self.identifier),
3306 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3307 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi),
3308 <fidl::encoding::Boxed<AdvertisingDataDeprecated> as fidl::encoding::ValueTypeMarker>::borrow(&self.advertising_data),
3309 ),
3310 encoder, offset, _depth
3311 )
3312 }
3313 }
3314 unsafe impl<
3315 D: fidl::encoding::ResourceDialect,
3316 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
3317 T1: fidl::encoding::Encode<bool, D>,
3318 T2: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3319 T3: fidl::encoding::Encode<fidl::encoding::Boxed<AdvertisingDataDeprecated>, D>,
3320 > fidl::encoding::Encode<RemoteDevice, D> for (T0, T1, T2, T3)
3321 {
3322 #[inline]
3323 unsafe fn encode(
3324 self,
3325 encoder: &mut fidl::encoding::Encoder<'_, D>,
3326 offset: usize,
3327 depth: fidl::encoding::Depth,
3328 ) -> fidl::Result<()> {
3329 encoder.debug_check_bounds::<RemoteDevice>(offset);
3330 unsafe {
3333 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
3334 (ptr as *mut u64).write_unaligned(0);
3335 }
3336 self.0.encode(encoder, offset + 0, depth)?;
3338 self.1.encode(encoder, offset + 16, depth)?;
3339 self.2.encode(encoder, offset + 24, depth)?;
3340 self.3.encode(encoder, offset + 32, depth)?;
3341 Ok(())
3342 }
3343 }
3344
3345 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RemoteDevice {
3346 #[inline(always)]
3347 fn new_empty() -> Self {
3348 Self {
3349 identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D),
3350 connectable: fidl::new_empty!(bool, D),
3351 rssi: fidl::new_empty!(
3352 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3353 D
3354 ),
3355 advertising_data: fidl::new_empty!(
3356 fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3357 D
3358 ),
3359 }
3360 }
3361
3362 #[inline]
3363 unsafe fn decode(
3364 &mut self,
3365 decoder: &mut fidl::encoding::Decoder<'_, D>,
3366 offset: usize,
3367 _depth: fidl::encoding::Depth,
3368 ) -> fidl::Result<()> {
3369 decoder.debug_check_bounds::<Self>(offset);
3370 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
3372 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3373 let mask = 0xffffffffffffff00u64;
3374 let maskedval = padval & mask;
3375 if maskedval != 0 {
3376 return Err(fidl::Error::NonZeroPadding {
3377 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
3378 });
3379 }
3380 fidl::decode!(
3381 fidl::encoding::BoundedString<16>,
3382 D,
3383 &mut self.identifier,
3384 decoder,
3385 offset + 0,
3386 _depth
3387 )?;
3388 fidl::decode!(bool, D, &mut self.connectable, decoder, offset + 16, _depth)?;
3389 fidl::decode!(
3390 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3391 D,
3392 &mut self.rssi,
3393 decoder,
3394 offset + 24,
3395 _depth
3396 )?;
3397 fidl::decode!(
3398 fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3399 D,
3400 &mut self.advertising_data,
3401 decoder,
3402 offset + 32,
3403 _depth
3404 )?;
3405 Ok(())
3406 }
3407 }
3408
3409 impl fidl::encoding::ValueTypeMarker for ScanFilter {
3410 type Borrowed<'a> = &'a Self;
3411 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3412 value
3413 }
3414 }
3415
3416 unsafe impl fidl::encoding::TypeMarker for ScanFilter {
3417 type Owned = Self;
3418
3419 #[inline(always)]
3420 fn inline_align(_context: fidl::encoding::Context) -> usize {
3421 8
3422 }
3423
3424 #[inline(always)]
3425 fn inline_size(_context: fidl::encoding::Context) -> usize {
3426 72
3427 }
3428 }
3429
3430 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanFilter, D>
3431 for &ScanFilter
3432 {
3433 #[inline]
3434 unsafe fn encode(
3435 self,
3436 encoder: &mut fidl::encoding::Encoder<'_, D>,
3437 offset: usize,
3438 _depth: fidl::encoding::Depth,
3439 ) -> fidl::Result<()> {
3440 encoder.debug_check_bounds::<ScanFilter>(offset);
3441 fidl::encoding::Encode::<ScanFilter, D>::encode(
3443 (
3444 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
3445 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data_uuids),
3446 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_identifier),
3447 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3448 <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name_substring),
3449 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.max_path_loss),
3450 ),
3451 encoder, offset, _depth
3452 )
3453 }
3454 }
3455 unsafe impl<
3456 D: fidl::encoding::ResourceDialect,
3457 T0: fidl::encoding::Encode<
3458 fidl::encoding::Optional<
3459 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3460 >,
3461 D,
3462 >,
3463 T1: fidl::encoding::Encode<
3464 fidl::encoding::Optional<
3465 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3466 >,
3467 D,
3468 >,
3469 T2: fidl::encoding::Encode<
3470 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3471 D,
3472 >,
3473 T3: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>, D>,
3474 T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
3475 T5: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3476 > fidl::encoding::Encode<ScanFilter, D> for (T0, T1, T2, T3, T4, T5)
3477 {
3478 #[inline]
3479 unsafe fn encode(
3480 self,
3481 encoder: &mut fidl::encoding::Encoder<'_, D>,
3482 offset: usize,
3483 depth: fidl::encoding::Depth,
3484 ) -> fidl::Result<()> {
3485 encoder.debug_check_bounds::<ScanFilter>(offset);
3486 self.0.encode(encoder, offset + 0, depth)?;
3490 self.1.encode(encoder, offset + 16, depth)?;
3491 self.2.encode(encoder, offset + 32, depth)?;
3492 self.3.encode(encoder, offset + 40, depth)?;
3493 self.4.encode(encoder, offset + 48, depth)?;
3494 self.5.encode(encoder, offset + 64, depth)?;
3495 Ok(())
3496 }
3497 }
3498
3499 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanFilter {
3500 #[inline(always)]
3501 fn new_empty() -> Self {
3502 Self {
3503 service_uuids: fidl::new_empty!(
3504 fidl::encoding::Optional<
3505 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3506 >,
3507 D
3508 ),
3509 service_data_uuids: fidl::new_empty!(
3510 fidl::encoding::Optional<
3511 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3512 >,
3513 D
3514 ),
3515 manufacturer_identifier: fidl::new_empty!(
3516 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3517 D
3518 ),
3519 connectable: fidl::new_empty!(
3520 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3521 D
3522 ),
3523 name_substring: fidl::new_empty!(
3524 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3525 D
3526 ),
3527 max_path_loss: fidl::new_empty!(
3528 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3529 D
3530 ),
3531 }
3532 }
3533
3534 #[inline]
3535 unsafe fn decode(
3536 &mut self,
3537 decoder: &mut fidl::encoding::Decoder<'_, D>,
3538 offset: usize,
3539 _depth: fidl::encoding::Depth,
3540 ) -> fidl::Result<()> {
3541 decoder.debug_check_bounds::<Self>(offset);
3542 fidl::decode!(
3544 fidl::encoding::Optional<
3545 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3546 >,
3547 D,
3548 &mut self.service_uuids,
3549 decoder,
3550 offset + 0,
3551 _depth
3552 )?;
3553 fidl::decode!(
3554 fidl::encoding::Optional<
3555 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3556 >,
3557 D,
3558 &mut self.service_data_uuids,
3559 decoder,
3560 offset + 16,
3561 _depth
3562 )?;
3563 fidl::decode!(
3564 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3565 D,
3566 &mut self.manufacturer_identifier,
3567 decoder,
3568 offset + 32,
3569 _depth
3570 )?;
3571 fidl::decode!(
3572 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3573 D,
3574 &mut self.connectable,
3575 decoder,
3576 offset + 40,
3577 _depth
3578 )?;
3579 fidl::decode!(
3580 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3581 D,
3582 &mut self.name_substring,
3583 decoder,
3584 offset + 48,
3585 _depth
3586 )?;
3587 fidl::decode!(
3588 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3589 D,
3590 &mut self.max_path_loss,
3591 decoder,
3592 offset + 64,
3593 _depth
3594 )?;
3595 Ok(())
3596 }
3597 }
3598
3599 impl fidl::encoding::ValueTypeMarker for ScanResultWatcherWatchResponse {
3600 type Borrowed<'a> = &'a Self;
3601 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3602 value
3603 }
3604 }
3605
3606 unsafe impl fidl::encoding::TypeMarker for ScanResultWatcherWatchResponse {
3607 type Owned = Self;
3608
3609 #[inline(always)]
3610 fn inline_align(_context: fidl::encoding::Context) -> usize {
3611 8
3612 }
3613
3614 #[inline(always)]
3615 fn inline_size(_context: fidl::encoding::Context) -> usize {
3616 16
3617 }
3618 }
3619
3620 unsafe impl<D: fidl::encoding::ResourceDialect>
3621 fidl::encoding::Encode<ScanResultWatcherWatchResponse, D>
3622 for &ScanResultWatcherWatchResponse
3623 {
3624 #[inline]
3625 unsafe fn encode(
3626 self,
3627 encoder: &mut fidl::encoding::Encoder<'_, D>,
3628 offset: usize,
3629 _depth: fidl::encoding::Depth,
3630 ) -> fidl::Result<()> {
3631 encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3632 fidl::encoding::Encode::<ScanResultWatcherWatchResponse, D>::encode(
3634 (
3635 <fidl::encoding::UnboundedVector<Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.updated),
3636 ),
3637 encoder, offset, _depth
3638 )
3639 }
3640 }
3641 unsafe impl<
3642 D: fidl::encoding::ResourceDialect,
3643 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Peer>, D>,
3644 > fidl::encoding::Encode<ScanResultWatcherWatchResponse, D> for (T0,)
3645 {
3646 #[inline]
3647 unsafe fn encode(
3648 self,
3649 encoder: &mut fidl::encoding::Encoder<'_, D>,
3650 offset: usize,
3651 depth: fidl::encoding::Depth,
3652 ) -> fidl::Result<()> {
3653 encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3654 self.0.encode(encoder, offset + 0, depth)?;
3658 Ok(())
3659 }
3660 }
3661
3662 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3663 for ScanResultWatcherWatchResponse
3664 {
3665 #[inline(always)]
3666 fn new_empty() -> Self {
3667 Self { updated: fidl::new_empty!(fidl::encoding::UnboundedVector<Peer>, D) }
3668 }
3669
3670 #[inline]
3671 unsafe fn decode(
3672 &mut self,
3673 decoder: &mut fidl::encoding::Decoder<'_, D>,
3674 offset: usize,
3675 _depth: fidl::encoding::Depth,
3676 ) -> fidl::Result<()> {
3677 decoder.debug_check_bounds::<Self>(offset);
3678 fidl::decode!(
3680 fidl::encoding::UnboundedVector<Peer>,
3681 D,
3682 &mut self.updated,
3683 decoder,
3684 offset + 0,
3685 _depth
3686 )?;
3687 Ok(())
3688 }
3689 }
3690
3691 impl fidl::encoding::ValueTypeMarker for ServiceData {
3692 type Borrowed<'a> = &'a Self;
3693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3694 value
3695 }
3696 }
3697
3698 unsafe impl fidl::encoding::TypeMarker for ServiceData {
3699 type Owned = Self;
3700
3701 #[inline(always)]
3702 fn inline_align(_context: fidl::encoding::Context) -> usize {
3703 8
3704 }
3705
3706 #[inline(always)]
3707 fn inline_size(_context: fidl::encoding::Context) -> usize {
3708 32
3709 }
3710 }
3711
3712 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceData, D>
3713 for &ServiceData
3714 {
3715 #[inline]
3716 unsafe fn encode(
3717 self,
3718 encoder: &mut fidl::encoding::Encoder<'_, D>,
3719 offset: usize,
3720 _depth: fidl::encoding::Depth,
3721 ) -> fidl::Result<()> {
3722 encoder.debug_check_bounds::<ServiceData>(offset);
3723 fidl::encoding::Encode::<ServiceData, D>::encode(
3725 (
3726 <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3727 <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3728 ),
3729 encoder, offset, _depth
3730 )
3731 }
3732 }
3733 unsafe impl<
3734 D: fidl::encoding::ResourceDialect,
3735 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Uuid, D>,
3736 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3737 > fidl::encoding::Encode<ServiceData, D> for (T0, T1)
3738 {
3739 #[inline]
3740 unsafe fn encode(
3741 self,
3742 encoder: &mut fidl::encoding::Encoder<'_, D>,
3743 offset: usize,
3744 depth: fidl::encoding::Depth,
3745 ) -> fidl::Result<()> {
3746 encoder.debug_check_bounds::<ServiceData>(offset);
3747 self.0.encode(encoder, offset + 0, depth)?;
3751 self.1.encode(encoder, offset + 16, depth)?;
3752 Ok(())
3753 }
3754 }
3755
3756 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceData {
3757 #[inline(always)]
3758 fn new_empty() -> Self {
3759 Self {
3760 uuid: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D),
3761 data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3762 }
3763 }
3764
3765 #[inline]
3766 unsafe fn decode(
3767 &mut self,
3768 decoder: &mut fidl::encoding::Decoder<'_, D>,
3769 offset: usize,
3770 _depth: fidl::encoding::Depth,
3771 ) -> fidl::Result<()> {
3772 decoder.debug_check_bounds::<Self>(offset);
3773 fidl::decode!(
3775 fidl_fuchsia_bluetooth__common::Uuid,
3776 D,
3777 &mut self.uuid,
3778 decoder,
3779 offset + 0,
3780 _depth
3781 )?;
3782 fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 16, _depth)?;
3783 Ok(())
3784 }
3785 }
3786
3787 impl fidl::encoding::ValueTypeMarker for ServiceDataEntry {
3788 type Borrowed<'a> = &'a Self;
3789 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3790 value
3791 }
3792 }
3793
3794 unsafe impl fidl::encoding::TypeMarker for ServiceDataEntry {
3795 type Owned = Self;
3796
3797 #[inline(always)]
3798 fn inline_align(_context: fidl::encoding::Context) -> usize {
3799 8
3800 }
3801
3802 #[inline(always)]
3803 fn inline_size(_context: fidl::encoding::Context) -> usize {
3804 32
3805 }
3806 }
3807
3808 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDataEntry, D>
3809 for &ServiceDataEntry
3810 {
3811 #[inline]
3812 unsafe fn encode(
3813 self,
3814 encoder: &mut fidl::encoding::Encoder<'_, D>,
3815 offset: usize,
3816 _depth: fidl::encoding::Depth,
3817 ) -> fidl::Result<()> {
3818 encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3819 fidl::encoding::Encode::<ServiceDataEntry, D>::encode(
3821 (
3822 <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3823 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3824 ),
3825 encoder, offset, _depth
3826 )
3827 }
3828 }
3829 unsafe impl<
3830 D: fidl::encoding::ResourceDialect,
3831 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
3832 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3833 > fidl::encoding::Encode<ServiceDataEntry, D> for (T0, T1)
3834 {
3835 #[inline]
3836 unsafe fn encode(
3837 self,
3838 encoder: &mut fidl::encoding::Encoder<'_, D>,
3839 offset: usize,
3840 depth: fidl::encoding::Depth,
3841 ) -> fidl::Result<()> {
3842 encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3843 self.0.encode(encoder, offset + 0, depth)?;
3847 self.1.encode(encoder, offset + 16, depth)?;
3848 Ok(())
3849 }
3850 }
3851
3852 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDataEntry {
3853 #[inline(always)]
3854 fn new_empty() -> Self {
3855 Self {
3856 uuid: fidl::new_empty!(fidl::encoding::BoundedString<36>, D),
3857 data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3858 }
3859 }
3860
3861 #[inline]
3862 unsafe fn decode(
3863 &mut self,
3864 decoder: &mut fidl::encoding::Decoder<'_, D>,
3865 offset: usize,
3866 _depth: fidl::encoding::Depth,
3867 ) -> fidl::Result<()> {
3868 decoder.debug_check_bounds::<Self>(offset);
3869 fidl::decode!(
3871 fidl::encoding::BoundedString<36>,
3872 D,
3873 &mut self.uuid,
3874 decoder,
3875 offset + 0,
3876 _depth
3877 )?;
3878 fidl::decode!(
3879 fidl::encoding::UnboundedVector<u8>,
3880 D,
3881 &mut self.data,
3882 decoder,
3883 offset + 16,
3884 _depth
3885 )?;
3886 Ok(())
3887 }
3888 }
3889
3890 impl AcceptedChannelParameters {
3891 #[inline(always)]
3892 fn max_ordinal_present(&self) -> u64 {
3893 if let Some(_) = self.max_packet_size {
3894 return 2;
3895 }
3896 if let Some(_) = self.accepted_channel_modes {
3897 return 1;
3898 }
3899 0
3900 }
3901 }
3902
3903 impl fidl::encoding::ValueTypeMarker for AcceptedChannelParameters {
3904 type Borrowed<'a> = &'a Self;
3905 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3906 value
3907 }
3908 }
3909
3910 unsafe impl fidl::encoding::TypeMarker for AcceptedChannelParameters {
3911 type Owned = Self;
3912
3913 #[inline(always)]
3914 fn inline_align(_context: fidl::encoding::Context) -> usize {
3915 8
3916 }
3917
3918 #[inline(always)]
3919 fn inline_size(_context: fidl::encoding::Context) -> usize {
3920 16
3921 }
3922 }
3923
3924 unsafe impl<D: fidl::encoding::ResourceDialect>
3925 fidl::encoding::Encode<AcceptedChannelParameters, D> for &AcceptedChannelParameters
3926 {
3927 unsafe fn encode(
3928 self,
3929 encoder: &mut fidl::encoding::Encoder<'_, D>,
3930 offset: usize,
3931 mut depth: fidl::encoding::Depth,
3932 ) -> fidl::Result<()> {
3933 encoder.debug_check_bounds::<AcceptedChannelParameters>(offset);
3934 let max_ordinal: u64 = self.max_ordinal_present();
3936 encoder.write_num(max_ordinal, offset);
3937 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3938 if max_ordinal == 0 {
3940 return Ok(());
3941 }
3942 depth.increment()?;
3943 let envelope_size = 8;
3944 let bytes_len = max_ordinal as usize * envelope_size;
3945 #[allow(unused_variables)]
3946 let offset = encoder.out_of_line_offset(bytes_len);
3947 let mut _prev_end_offset: usize = 0;
3948 if 1 > max_ordinal {
3949 return Ok(());
3950 }
3951
3952 let cur_offset: usize = (1 - 1) * envelope_size;
3955
3956 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3958
3959 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>, D>(
3964 self.accepted_channel_modes.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode> as fidl::encoding::ValueTypeMarker>::borrow),
3965 encoder, offset + cur_offset, depth
3966 )?;
3967
3968 _prev_end_offset = cur_offset + envelope_size;
3969 if 2 > max_ordinal {
3970 return Ok(());
3971 }
3972
3973 let cur_offset: usize = (2 - 1) * envelope_size;
3976
3977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3979
3980 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3985 self.max_packet_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3986 encoder,
3987 offset + cur_offset,
3988 depth,
3989 )?;
3990
3991 _prev_end_offset = cur_offset + envelope_size;
3992
3993 Ok(())
3994 }
3995 }
3996
3997 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3998 for AcceptedChannelParameters
3999 {
4000 #[inline(always)]
4001 fn new_empty() -> Self {
4002 Self::default()
4003 }
4004
4005 unsafe fn decode(
4006 &mut self,
4007 decoder: &mut fidl::encoding::Decoder<'_, D>,
4008 offset: usize,
4009 mut depth: fidl::encoding::Depth,
4010 ) -> fidl::Result<()> {
4011 decoder.debug_check_bounds::<Self>(offset);
4012 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4013 None => return Err(fidl::Error::NotNullable),
4014 Some(len) => len,
4015 };
4016 if len == 0 {
4018 return Ok(());
4019 };
4020 depth.increment()?;
4021 let envelope_size = 8;
4022 let bytes_len = len * envelope_size;
4023 let offset = decoder.out_of_line_offset(bytes_len)?;
4024 let mut _next_ordinal_to_read = 0;
4026 let mut next_offset = offset;
4027 let end_offset = offset + bytes_len;
4028 _next_ordinal_to_read += 1;
4029 if next_offset >= end_offset {
4030 return Ok(());
4031 }
4032
4033 while _next_ordinal_to_read < 1 {
4035 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4036 _next_ordinal_to_read += 1;
4037 next_offset += envelope_size;
4038 }
4039
4040 let next_out_of_line = decoder.next_out_of_line();
4041 let handles_before = decoder.remaining_handles();
4042 if let Some((inlined, num_bytes, num_handles)) =
4043 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4044 {
4045 let member_inline_size = <fidl::encoding::UnboundedVector<
4046 fidl_fuchsia_bluetooth__common::ChannelMode,
4047 > as fidl::encoding::TypeMarker>::inline_size(
4048 decoder.context
4049 );
4050 if inlined != (member_inline_size <= 4) {
4051 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4052 }
4053 let inner_offset;
4054 let mut inner_depth = depth.clone();
4055 if inlined {
4056 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4057 inner_offset = next_offset;
4058 } else {
4059 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4060 inner_depth.increment()?;
4061 }
4062 let val_ref = self.accepted_channel_modes.get_or_insert_with(|| {
4063 fidl::new_empty!(
4064 fidl::encoding::UnboundedVector<
4065 fidl_fuchsia_bluetooth__common::ChannelMode,
4066 >,
4067 D
4068 )
4069 });
4070 fidl::decode!(
4071 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>,
4072 D,
4073 val_ref,
4074 decoder,
4075 inner_offset,
4076 inner_depth
4077 )?;
4078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4079 {
4080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4081 }
4082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4084 }
4085 }
4086
4087 next_offset += envelope_size;
4088 _next_ordinal_to_read += 1;
4089 if next_offset >= end_offset {
4090 return Ok(());
4091 }
4092
4093 while _next_ordinal_to_read < 2 {
4095 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4096 _next_ordinal_to_read += 1;
4097 next_offset += envelope_size;
4098 }
4099
4100 let next_out_of_line = decoder.next_out_of_line();
4101 let handles_before = decoder.remaining_handles();
4102 if let Some((inlined, num_bytes, num_handles)) =
4103 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4104 {
4105 let member_inline_size =
4106 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4107 if inlined != (member_inline_size <= 4) {
4108 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4109 }
4110 let inner_offset;
4111 let mut inner_depth = depth.clone();
4112 if inlined {
4113 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4114 inner_offset = next_offset;
4115 } else {
4116 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4117 inner_depth.increment()?;
4118 }
4119 let val_ref = self.max_packet_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
4120 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4121 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4122 {
4123 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4124 }
4125 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4126 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4127 }
4128 }
4129
4130 next_offset += envelope_size;
4131
4132 while next_offset < end_offset {
4134 _next_ordinal_to_read += 1;
4135 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4136 next_offset += envelope_size;
4137 }
4138
4139 Ok(())
4140 }
4141 }
4142
4143 impl AdvertisingData {
4144 #[inline(always)]
4145 fn max_ordinal_present(&self) -> u64 {
4146 if let Some(_) = self.broadcast_name {
4147 return 10;
4148 }
4149 if let Some(_) = self.resolvable_set_identifier {
4150 return 9;
4151 }
4152 if let Some(_) = self.include_tx_power_level {
4153 return 8;
4154 }
4155 if let Some(_) = self.uris {
4156 return 7;
4157 }
4158 if let Some(_) = self.manufacturer_data {
4159 return 6;
4160 }
4161 if let Some(_) = self.service_data {
4162 return 5;
4163 }
4164 if let Some(_) = self.service_uuids {
4165 return 4;
4166 }
4167 if let Some(_) = self.tx_power_level {
4168 return 3;
4169 }
4170 if let Some(_) = self.appearance {
4171 return 2;
4172 }
4173 if let Some(_) = self.name {
4174 return 1;
4175 }
4176 0
4177 }
4178 }
4179
4180 impl fidl::encoding::ValueTypeMarker for AdvertisingData {
4181 type Borrowed<'a> = &'a Self;
4182 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4183 value
4184 }
4185 }
4186
4187 unsafe impl fidl::encoding::TypeMarker for AdvertisingData {
4188 type Owned = Self;
4189
4190 #[inline(always)]
4191 fn inline_align(_context: fidl::encoding::Context) -> usize {
4192 8
4193 }
4194
4195 #[inline(always)]
4196 fn inline_size(_context: fidl::encoding::Context) -> usize {
4197 16
4198 }
4199 }
4200
4201 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingData, D>
4202 for &AdvertisingData
4203 {
4204 unsafe fn encode(
4205 self,
4206 encoder: &mut fidl::encoding::Encoder<'_, D>,
4207 offset: usize,
4208 mut depth: fidl::encoding::Depth,
4209 ) -> fidl::Result<()> {
4210 encoder.debug_check_bounds::<AdvertisingData>(offset);
4211 let max_ordinal: u64 = self.max_ordinal_present();
4213 encoder.write_num(max_ordinal, offset);
4214 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4215 if max_ordinal == 0 {
4217 return Ok(());
4218 }
4219 depth.increment()?;
4220 let envelope_size = 8;
4221 let bytes_len = max_ordinal as usize * envelope_size;
4222 #[allow(unused_variables)]
4223 let offset = encoder.out_of_line_offset(bytes_len);
4224 let mut _prev_end_offset: usize = 0;
4225 if 1 > max_ordinal {
4226 return Ok(());
4227 }
4228
4229 let cur_offset: usize = (1 - 1) * envelope_size;
4232
4233 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4235
4236 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
4241 self.name.as_ref().map(
4242 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
4243 ),
4244 encoder,
4245 offset + cur_offset,
4246 depth,
4247 )?;
4248
4249 _prev_end_offset = cur_offset + envelope_size;
4250 if 2 > max_ordinal {
4251 return Ok(());
4252 }
4253
4254 let cur_offset: usize = (2 - 1) * envelope_size;
4257
4258 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4260
4261 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
4266 self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
4267 encoder, offset + cur_offset, depth
4268 )?;
4269
4270 _prev_end_offset = cur_offset + envelope_size;
4271 if 3 > max_ordinal {
4272 return Ok(());
4273 }
4274
4275 let cur_offset: usize = (3 - 1) * envelope_size;
4278
4279 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4281
4282 fidl::encoding::encode_in_envelope_optional::<i8, D>(
4287 self.tx_power_level.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4288 encoder,
4289 offset + cur_offset,
4290 depth,
4291 )?;
4292
4293 _prev_end_offset = cur_offset + envelope_size;
4294 if 4 > max_ordinal {
4295 return Ok(());
4296 }
4297
4298 let cur_offset: usize = (4 - 1) * envelope_size;
4301
4302 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4304
4305 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
4310 self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
4311 encoder, offset + cur_offset, depth
4312 )?;
4313
4314 _prev_end_offset = cur_offset + envelope_size;
4315 if 5 > max_ordinal {
4316 return Ok(());
4317 }
4318
4319 let cur_offset: usize = (5 - 1) * envelope_size;
4322
4323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4325
4326 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
4331 self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
4332 encoder, offset + cur_offset, depth
4333 )?;
4334
4335 _prev_end_offset = cur_offset + envelope_size;
4336 if 6 > max_ordinal {
4337 return Ok(());
4338 }
4339
4340 let cur_offset: usize = (6 - 1) * envelope_size;
4343
4344 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4346
4347 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
4352 self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
4353 encoder, offset + cur_offset, depth
4354 )?;
4355
4356 _prev_end_offset = cur_offset + envelope_size;
4357 if 7 > max_ordinal {
4358 return Ok(());
4359 }
4360
4361 let cur_offset: usize = (7 - 1) * envelope_size;
4364
4365 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4367
4368 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
4373 self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
4374 encoder, offset + cur_offset, depth
4375 )?;
4376
4377 _prev_end_offset = cur_offset + envelope_size;
4378 if 8 > max_ordinal {
4379 return Ok(());
4380 }
4381
4382 let cur_offset: usize = (8 - 1) * envelope_size;
4385
4386 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4388
4389 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4394 self.include_tx_power_level
4395 .as_ref()
4396 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4397 encoder,
4398 offset + cur_offset,
4399 depth,
4400 )?;
4401
4402 _prev_end_offset = cur_offset + envelope_size;
4403 if 9 > max_ordinal {
4404 return Ok(());
4405 }
4406
4407 let cur_offset: usize = (9 - 1) * envelope_size;
4410
4411 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4413
4414 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4419 self.resolvable_set_identifier
4420 .as_ref()
4421 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4422 encoder,
4423 offset + cur_offset,
4424 depth,
4425 )?;
4426
4427 _prev_end_offset = cur_offset + envelope_size;
4428 if 10 > max_ordinal {
4429 return Ok(());
4430 }
4431
4432 let cur_offset: usize = (10 - 1) * envelope_size;
4435
4436 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4438
4439 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
4444 self.broadcast_name.as_ref().map(
4445 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
4446 ),
4447 encoder,
4448 offset + cur_offset,
4449 depth,
4450 )?;
4451
4452 _prev_end_offset = cur_offset + envelope_size;
4453
4454 Ok(())
4455 }
4456 }
4457
4458 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingData {
4459 #[inline(always)]
4460 fn new_empty() -> Self {
4461 Self::default()
4462 }
4463
4464 unsafe fn decode(
4465 &mut self,
4466 decoder: &mut fidl::encoding::Decoder<'_, D>,
4467 offset: usize,
4468 mut depth: fidl::encoding::Depth,
4469 ) -> fidl::Result<()> {
4470 decoder.debug_check_bounds::<Self>(offset);
4471 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4472 None => return Err(fidl::Error::NotNullable),
4473 Some(len) => len,
4474 };
4475 if len == 0 {
4477 return Ok(());
4478 };
4479 depth.increment()?;
4480 let envelope_size = 8;
4481 let bytes_len = len * envelope_size;
4482 let offset = decoder.out_of_line_offset(bytes_len)?;
4483 let mut _next_ordinal_to_read = 0;
4485 let mut next_offset = offset;
4486 let end_offset = offset + bytes_len;
4487 _next_ordinal_to_read += 1;
4488 if next_offset >= end_offset {
4489 return Ok(());
4490 }
4491
4492 while _next_ordinal_to_read < 1 {
4494 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4495 _next_ordinal_to_read += 1;
4496 next_offset += envelope_size;
4497 }
4498
4499 let next_out_of_line = decoder.next_out_of_line();
4500 let handles_before = decoder.remaining_handles();
4501 if let Some((inlined, num_bytes, num_handles)) =
4502 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4503 {
4504 let member_inline_size =
4505 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
4506 decoder.context,
4507 );
4508 if inlined != (member_inline_size <= 4) {
4509 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4510 }
4511 let inner_offset;
4512 let mut inner_depth = depth.clone();
4513 if inlined {
4514 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4515 inner_offset = next_offset;
4516 } else {
4517 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4518 inner_depth.increment()?;
4519 }
4520 let val_ref = self
4521 .name
4522 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
4523 fidl::decode!(
4524 fidl::encoding::BoundedString<248>,
4525 D,
4526 val_ref,
4527 decoder,
4528 inner_offset,
4529 inner_depth
4530 )?;
4531 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4532 {
4533 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4534 }
4535 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4536 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4537 }
4538 }
4539
4540 next_offset += envelope_size;
4541 _next_ordinal_to_read += 1;
4542 if next_offset >= end_offset {
4543 return Ok(());
4544 }
4545
4546 while _next_ordinal_to_read < 2 {
4548 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4549 _next_ordinal_to_read += 1;
4550 next_offset += envelope_size;
4551 }
4552
4553 let next_out_of_line = decoder.next_out_of_line();
4554 let handles_before = decoder.remaining_handles();
4555 if let Some((inlined, num_bytes, num_handles)) =
4556 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4557 {
4558 let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4559 if inlined != (member_inline_size <= 4) {
4560 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4561 }
4562 let inner_offset;
4563 let mut inner_depth = depth.clone();
4564 if inlined {
4565 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4566 inner_offset = next_offset;
4567 } else {
4568 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4569 inner_depth.increment()?;
4570 }
4571 let val_ref = self.appearance.get_or_insert_with(|| {
4572 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
4573 });
4574 fidl::decode!(
4575 fidl_fuchsia_bluetooth__common::Appearance,
4576 D,
4577 val_ref,
4578 decoder,
4579 inner_offset,
4580 inner_depth
4581 )?;
4582 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4583 {
4584 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4585 }
4586 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4587 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4588 }
4589 }
4590
4591 next_offset += envelope_size;
4592 _next_ordinal_to_read += 1;
4593 if next_offset >= end_offset {
4594 return Ok(());
4595 }
4596
4597 while _next_ordinal_to_read < 3 {
4599 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4600 _next_ordinal_to_read += 1;
4601 next_offset += envelope_size;
4602 }
4603
4604 let next_out_of_line = decoder.next_out_of_line();
4605 let handles_before = decoder.remaining_handles();
4606 if let Some((inlined, num_bytes, num_handles)) =
4607 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4608 {
4609 let member_inline_size =
4610 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4611 if inlined != (member_inline_size <= 4) {
4612 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4613 }
4614 let inner_offset;
4615 let mut inner_depth = depth.clone();
4616 if inlined {
4617 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4618 inner_offset = next_offset;
4619 } else {
4620 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4621 inner_depth.increment()?;
4622 }
4623 let val_ref = self.tx_power_level.get_or_insert_with(|| fidl::new_empty!(i8, D));
4624 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
4625 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4626 {
4627 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4628 }
4629 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4630 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4631 }
4632 }
4633
4634 next_offset += envelope_size;
4635 _next_ordinal_to_read += 1;
4636 if next_offset >= end_offset {
4637 return Ok(());
4638 }
4639
4640 while _next_ordinal_to_read < 4 {
4642 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4643 _next_ordinal_to_read += 1;
4644 next_offset += envelope_size;
4645 }
4646
4647 let next_out_of_line = decoder.next_out_of_line();
4648 let handles_before = decoder.remaining_handles();
4649 if let Some((inlined, num_bytes, num_handles)) =
4650 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4651 {
4652 let member_inline_size = <fidl::encoding::UnboundedVector<
4653 fidl_fuchsia_bluetooth__common::Uuid,
4654 > as fidl::encoding::TypeMarker>::inline_size(
4655 decoder.context
4656 );
4657 if inlined != (member_inline_size <= 4) {
4658 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4659 }
4660 let inner_offset;
4661 let mut inner_depth = depth.clone();
4662 if inlined {
4663 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4664 inner_offset = next_offset;
4665 } else {
4666 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4667 inner_depth.increment()?;
4668 }
4669 let val_ref = self.service_uuids.get_or_insert_with(|| {
4670 fidl::new_empty!(
4671 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4672 D
4673 )
4674 });
4675 fidl::decode!(
4676 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4677 D,
4678 val_ref,
4679 decoder,
4680 inner_offset,
4681 inner_depth
4682 )?;
4683 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4684 {
4685 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4686 }
4687 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4688 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4689 }
4690 }
4691
4692 next_offset += envelope_size;
4693 _next_ordinal_to_read += 1;
4694 if next_offset >= end_offset {
4695 return Ok(());
4696 }
4697
4698 while _next_ordinal_to_read < 5 {
4700 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4701 _next_ordinal_to_read += 1;
4702 next_offset += envelope_size;
4703 }
4704
4705 let next_out_of_line = decoder.next_out_of_line();
4706 let handles_before = decoder.remaining_handles();
4707 if let Some((inlined, num_bytes, num_handles)) =
4708 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4709 {
4710 let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4711 if inlined != (member_inline_size <= 4) {
4712 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4713 }
4714 let inner_offset;
4715 let mut inner_depth = depth.clone();
4716 if inlined {
4717 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4718 inner_offset = next_offset;
4719 } else {
4720 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4721 inner_depth.increment()?;
4722 }
4723 let val_ref = self.service_data.get_or_insert_with(|| {
4724 fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
4725 });
4726 fidl::decode!(
4727 fidl::encoding::UnboundedVector<ServiceData>,
4728 D,
4729 val_ref,
4730 decoder,
4731 inner_offset,
4732 inner_depth
4733 )?;
4734 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4735 {
4736 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4737 }
4738 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4739 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4740 }
4741 }
4742
4743 next_offset += envelope_size;
4744 _next_ordinal_to_read += 1;
4745 if next_offset >= end_offset {
4746 return Ok(());
4747 }
4748
4749 while _next_ordinal_to_read < 6 {
4751 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4752 _next_ordinal_to_read += 1;
4753 next_offset += envelope_size;
4754 }
4755
4756 let next_out_of_line = decoder.next_out_of_line();
4757 let handles_before = decoder.remaining_handles();
4758 if let Some((inlined, num_bytes, num_handles)) =
4759 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4760 {
4761 let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4762 if inlined != (member_inline_size <= 4) {
4763 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4764 }
4765 let inner_offset;
4766 let mut inner_depth = depth.clone();
4767 if inlined {
4768 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4769 inner_offset = next_offset;
4770 } else {
4771 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4772 inner_depth.increment()?;
4773 }
4774 let val_ref = self.manufacturer_data.get_or_insert_with(|| {
4775 fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
4776 });
4777 fidl::decode!(
4778 fidl::encoding::UnboundedVector<ManufacturerData>,
4779 D,
4780 val_ref,
4781 decoder,
4782 inner_offset,
4783 inner_depth
4784 )?;
4785 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4786 {
4787 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4788 }
4789 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4790 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4791 }
4792 }
4793
4794 next_offset += envelope_size;
4795 _next_ordinal_to_read += 1;
4796 if next_offset >= end_offset {
4797 return Ok(());
4798 }
4799
4800 while _next_ordinal_to_read < 7 {
4802 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4803 _next_ordinal_to_read += 1;
4804 next_offset += envelope_size;
4805 }
4806
4807 let next_out_of_line = decoder.next_out_of_line();
4808 let handles_before = decoder.remaining_handles();
4809 if let Some((inlined, num_bytes, num_handles)) =
4810 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4811 {
4812 let member_inline_size = <fidl::encoding::UnboundedVector<
4813 fidl::encoding::BoundedString<278>,
4814 > as fidl::encoding::TypeMarker>::inline_size(
4815 decoder.context
4816 );
4817 if inlined != (member_inline_size <= 4) {
4818 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4819 }
4820 let inner_offset;
4821 let mut inner_depth = depth.clone();
4822 if inlined {
4823 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4824 inner_offset = next_offset;
4825 } else {
4826 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4827 inner_depth.increment()?;
4828 }
4829 let val_ref = self.uris.get_or_insert_with(|| {
4830 fidl::new_empty!(
4831 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4832 D
4833 )
4834 });
4835 fidl::decode!(
4836 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4837 D,
4838 val_ref,
4839 decoder,
4840 inner_offset,
4841 inner_depth
4842 )?;
4843 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4844 {
4845 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4846 }
4847 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4848 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4849 }
4850 }
4851
4852 next_offset += envelope_size;
4853 _next_ordinal_to_read += 1;
4854 if next_offset >= end_offset {
4855 return Ok(());
4856 }
4857
4858 while _next_ordinal_to_read < 8 {
4860 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4861 _next_ordinal_to_read += 1;
4862 next_offset += envelope_size;
4863 }
4864
4865 let next_out_of_line = decoder.next_out_of_line();
4866 let handles_before = decoder.remaining_handles();
4867 if let Some((inlined, num_bytes, num_handles)) =
4868 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4869 {
4870 let member_inline_size =
4871 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4872 if inlined != (member_inline_size <= 4) {
4873 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4874 }
4875 let inner_offset;
4876 let mut inner_depth = depth.clone();
4877 if inlined {
4878 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4879 inner_offset = next_offset;
4880 } else {
4881 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4882 inner_depth.increment()?;
4883 }
4884 let val_ref =
4885 self.include_tx_power_level.get_or_insert_with(|| fidl::new_empty!(bool, D));
4886 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4887 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4888 {
4889 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4890 }
4891 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4892 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4893 }
4894 }
4895
4896 next_offset += envelope_size;
4897 _next_ordinal_to_read += 1;
4898 if next_offset >= end_offset {
4899 return Ok(());
4900 }
4901
4902 while _next_ordinal_to_read < 9 {
4904 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4905 _next_ordinal_to_read += 1;
4906 next_offset += envelope_size;
4907 }
4908
4909 let next_out_of_line = decoder.next_out_of_line();
4910 let handles_before = decoder.remaining_handles();
4911 if let Some((inlined, num_bytes, num_handles)) =
4912 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4913 {
4914 let member_inline_size =
4915 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4916 decoder.context,
4917 );
4918 if inlined != (member_inline_size <= 4) {
4919 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4920 }
4921 let inner_offset;
4922 let mut inner_depth = depth.clone();
4923 if inlined {
4924 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4925 inner_offset = next_offset;
4926 } else {
4927 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4928 inner_depth.increment()?;
4929 }
4930 let val_ref = self
4931 .resolvable_set_identifier
4932 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4933 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4934 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4935 {
4936 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4937 }
4938 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4939 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4940 }
4941 }
4942
4943 next_offset += envelope_size;
4944 _next_ordinal_to_read += 1;
4945 if next_offset >= end_offset {
4946 return Ok(());
4947 }
4948
4949 while _next_ordinal_to_read < 10 {
4951 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4952 _next_ordinal_to_read += 1;
4953 next_offset += envelope_size;
4954 }
4955
4956 let next_out_of_line = decoder.next_out_of_line();
4957 let handles_before = decoder.remaining_handles();
4958 if let Some((inlined, num_bytes, num_handles)) =
4959 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4960 {
4961 let member_inline_size =
4962 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
4963 decoder.context,
4964 );
4965 if inlined != (member_inline_size <= 4) {
4966 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4967 }
4968 let inner_offset;
4969 let mut inner_depth = depth.clone();
4970 if inlined {
4971 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4972 inner_offset = next_offset;
4973 } else {
4974 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4975 inner_depth.increment()?;
4976 }
4977 let val_ref = self
4978 .broadcast_name
4979 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
4980 fidl::decode!(
4981 fidl::encoding::BoundedString<128>,
4982 D,
4983 val_ref,
4984 decoder,
4985 inner_offset,
4986 inner_depth
4987 )?;
4988 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4989 {
4990 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4991 }
4992 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4993 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4994 }
4995 }
4996
4997 next_offset += envelope_size;
4998
4999 while next_offset < end_offset {
5001 _next_ordinal_to_read += 1;
5002 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5003 next_offset += envelope_size;
5004 }
5005
5006 Ok(())
5007 }
5008 }
5009
5010 impl AdvertisingParameters {
5011 #[inline(always)]
5012 fn max_ordinal_present(&self) -> u64 {
5013 if let Some(_) = self.address_type {
5014 return 7;
5015 }
5016 if let Some(_) = self.advertising_procedure {
5017 return 6;
5018 }
5019 if let Some(_) = self.connection_options {
5020 return 5;
5021 }
5022 if let Some(_) = self.connectable {
5023 return 4;
5024 }
5025 if let Some(_) = self.mode_hint {
5026 return 3;
5027 }
5028 if let Some(_) = self.scan_response {
5029 return 2;
5030 }
5031 if let Some(_) = self.data {
5032 return 1;
5033 }
5034 0
5035 }
5036 }
5037
5038 impl fidl::encoding::ValueTypeMarker for AdvertisingParameters {
5039 type Borrowed<'a> = &'a Self;
5040 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5041 value
5042 }
5043 }
5044
5045 unsafe impl fidl::encoding::TypeMarker for AdvertisingParameters {
5046 type Owned = Self;
5047
5048 #[inline(always)]
5049 fn inline_align(_context: fidl::encoding::Context) -> usize {
5050 8
5051 }
5052
5053 #[inline(always)]
5054 fn inline_size(_context: fidl::encoding::Context) -> usize {
5055 16
5056 }
5057 }
5058
5059 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingParameters, D>
5060 for &AdvertisingParameters
5061 {
5062 unsafe fn encode(
5063 self,
5064 encoder: &mut fidl::encoding::Encoder<'_, D>,
5065 offset: usize,
5066 mut depth: fidl::encoding::Depth,
5067 ) -> fidl::Result<()> {
5068 encoder.debug_check_bounds::<AdvertisingParameters>(offset);
5069 let max_ordinal: u64 = self.max_ordinal_present();
5071 encoder.write_num(max_ordinal, offset);
5072 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5073 if max_ordinal == 0 {
5075 return Ok(());
5076 }
5077 depth.increment()?;
5078 let envelope_size = 8;
5079 let bytes_len = max_ordinal as usize * envelope_size;
5080 #[allow(unused_variables)]
5081 let offset = encoder.out_of_line_offset(bytes_len);
5082 let mut _prev_end_offset: usize = 0;
5083 if 1 > max_ordinal {
5084 return Ok(());
5085 }
5086
5087 let cur_offset: usize = (1 - 1) * envelope_size;
5090
5091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5093
5094 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5099 self.data
5100 .as_ref()
5101 .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5102 encoder,
5103 offset + cur_offset,
5104 depth,
5105 )?;
5106
5107 _prev_end_offset = cur_offset + envelope_size;
5108 if 2 > max_ordinal {
5109 return Ok(());
5110 }
5111
5112 let cur_offset: usize = (2 - 1) * envelope_size;
5115
5116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5118
5119 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5124 self.scan_response
5125 .as_ref()
5126 .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5127 encoder,
5128 offset + cur_offset,
5129 depth,
5130 )?;
5131
5132 _prev_end_offset = cur_offset + envelope_size;
5133 if 3 > max_ordinal {
5134 return Ok(());
5135 }
5136
5137 let cur_offset: usize = (3 - 1) * envelope_size;
5140
5141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5143
5144 fidl::encoding::encode_in_envelope_optional::<AdvertisingModeHint, D>(
5149 self.mode_hint
5150 .as_ref()
5151 .map(<AdvertisingModeHint as fidl::encoding::ValueTypeMarker>::borrow),
5152 encoder,
5153 offset + cur_offset,
5154 depth,
5155 )?;
5156
5157 _prev_end_offset = cur_offset + envelope_size;
5158 if 4 > max_ordinal {
5159 return Ok(());
5160 }
5161
5162 let cur_offset: usize = (4 - 1) * envelope_size;
5165
5166 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5168
5169 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5174 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5175 encoder,
5176 offset + cur_offset,
5177 depth,
5178 )?;
5179
5180 _prev_end_offset = cur_offset + envelope_size;
5181 if 5 > max_ordinal {
5182 return Ok(());
5183 }
5184
5185 let cur_offset: usize = (5 - 1) * envelope_size;
5188
5189 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5191
5192 fidl::encoding::encode_in_envelope_optional::<ConnectionOptions, D>(
5197 self.connection_options
5198 .as_ref()
5199 .map(<ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow),
5200 encoder,
5201 offset + cur_offset,
5202 depth,
5203 )?;
5204
5205 _prev_end_offset = cur_offset + envelope_size;
5206 if 6 > max_ordinal {
5207 return Ok(());
5208 }
5209
5210 let cur_offset: usize = (6 - 1) * envelope_size;
5213
5214 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5216
5217 fidl::encoding::encode_in_envelope_optional::<AdvertisingProcedure, D>(
5222 self.advertising_procedure
5223 .as_ref()
5224 .map(<AdvertisingProcedure as fidl::encoding::ValueTypeMarker>::borrow),
5225 encoder,
5226 offset + cur_offset,
5227 depth,
5228 )?;
5229
5230 _prev_end_offset = cur_offset + envelope_size;
5231 if 7 > max_ordinal {
5232 return Ok(());
5233 }
5234
5235 let cur_offset: usize = (7 - 1) * envelope_size;
5238
5239 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5241
5242 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AddressType, D>(
5247 self.address_type.as_ref().map(<fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::ValueTypeMarker>::borrow),
5248 encoder, offset + cur_offset, depth
5249 )?;
5250
5251 _prev_end_offset = cur_offset + envelope_size;
5252
5253 Ok(())
5254 }
5255 }
5256
5257 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingParameters {
5258 #[inline(always)]
5259 fn new_empty() -> Self {
5260 Self::default()
5261 }
5262
5263 unsafe fn decode(
5264 &mut self,
5265 decoder: &mut fidl::encoding::Decoder<'_, D>,
5266 offset: usize,
5267 mut depth: fidl::encoding::Depth,
5268 ) -> fidl::Result<()> {
5269 decoder.debug_check_bounds::<Self>(offset);
5270 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5271 None => return Err(fidl::Error::NotNullable),
5272 Some(len) => len,
5273 };
5274 if len == 0 {
5276 return Ok(());
5277 };
5278 depth.increment()?;
5279 let envelope_size = 8;
5280 let bytes_len = len * envelope_size;
5281 let offset = decoder.out_of_line_offset(bytes_len)?;
5282 let mut _next_ordinal_to_read = 0;
5284 let mut next_offset = offset;
5285 let end_offset = offset + bytes_len;
5286 _next_ordinal_to_read += 1;
5287 if next_offset >= end_offset {
5288 return Ok(());
5289 }
5290
5291 while _next_ordinal_to_read < 1 {
5293 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5294 _next_ordinal_to_read += 1;
5295 next_offset += envelope_size;
5296 }
5297
5298 let next_out_of_line = decoder.next_out_of_line();
5299 let handles_before = decoder.remaining_handles();
5300 if let Some((inlined, num_bytes, num_handles)) =
5301 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5302 {
5303 let member_inline_size =
5304 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5305 if inlined != (member_inline_size <= 4) {
5306 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5307 }
5308 let inner_offset;
5309 let mut inner_depth = depth.clone();
5310 if inlined {
5311 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5312 inner_offset = next_offset;
5313 } else {
5314 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5315 inner_depth.increment()?;
5316 }
5317 let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5318 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5319 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5320 {
5321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5322 }
5323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5325 }
5326 }
5327
5328 next_offset += envelope_size;
5329 _next_ordinal_to_read += 1;
5330 if next_offset >= end_offset {
5331 return Ok(());
5332 }
5333
5334 while _next_ordinal_to_read < 2 {
5336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5337 _next_ordinal_to_read += 1;
5338 next_offset += envelope_size;
5339 }
5340
5341 let next_out_of_line = decoder.next_out_of_line();
5342 let handles_before = decoder.remaining_handles();
5343 if let Some((inlined, num_bytes, num_handles)) =
5344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5345 {
5346 let member_inline_size =
5347 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5348 if inlined != (member_inline_size <= 4) {
5349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5350 }
5351 let inner_offset;
5352 let mut inner_depth = depth.clone();
5353 if inlined {
5354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5355 inner_offset = next_offset;
5356 } else {
5357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5358 inner_depth.increment()?;
5359 }
5360 let val_ref =
5361 self.scan_response.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5362 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5363 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5364 {
5365 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5366 }
5367 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5368 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5369 }
5370 }
5371
5372 next_offset += envelope_size;
5373 _next_ordinal_to_read += 1;
5374 if next_offset >= end_offset {
5375 return Ok(());
5376 }
5377
5378 while _next_ordinal_to_read < 3 {
5380 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5381 _next_ordinal_to_read += 1;
5382 next_offset += envelope_size;
5383 }
5384
5385 let next_out_of_line = decoder.next_out_of_line();
5386 let handles_before = decoder.remaining_handles();
5387 if let Some((inlined, num_bytes, num_handles)) =
5388 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5389 {
5390 let member_inline_size =
5391 <AdvertisingModeHint as fidl::encoding::TypeMarker>::inline_size(
5392 decoder.context,
5393 );
5394 if inlined != (member_inline_size <= 4) {
5395 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5396 }
5397 let inner_offset;
5398 let mut inner_depth = depth.clone();
5399 if inlined {
5400 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5401 inner_offset = next_offset;
5402 } else {
5403 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5404 inner_depth.increment()?;
5405 }
5406 let val_ref =
5407 self.mode_hint.get_or_insert_with(|| fidl::new_empty!(AdvertisingModeHint, D));
5408 fidl::decode!(AdvertisingModeHint, D, val_ref, decoder, inner_offset, inner_depth)?;
5409 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5410 {
5411 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5412 }
5413 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5414 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5415 }
5416 }
5417
5418 next_offset += envelope_size;
5419 _next_ordinal_to_read += 1;
5420 if next_offset >= end_offset {
5421 return Ok(());
5422 }
5423
5424 while _next_ordinal_to_read < 4 {
5426 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5427 _next_ordinal_to_read += 1;
5428 next_offset += envelope_size;
5429 }
5430
5431 let next_out_of_line = decoder.next_out_of_line();
5432 let handles_before = decoder.remaining_handles();
5433 if let Some((inlined, num_bytes, num_handles)) =
5434 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5435 {
5436 let member_inline_size =
5437 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5438 if inlined != (member_inline_size <= 4) {
5439 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5440 }
5441 let inner_offset;
5442 let mut inner_depth = depth.clone();
5443 if inlined {
5444 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5445 inner_offset = next_offset;
5446 } else {
5447 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5448 inner_depth.increment()?;
5449 }
5450 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5451 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5452 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5453 {
5454 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5455 }
5456 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5457 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5458 }
5459 }
5460
5461 next_offset += envelope_size;
5462 _next_ordinal_to_read += 1;
5463 if next_offset >= end_offset {
5464 return Ok(());
5465 }
5466
5467 while _next_ordinal_to_read < 5 {
5469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5470 _next_ordinal_to_read += 1;
5471 next_offset += envelope_size;
5472 }
5473
5474 let next_out_of_line = decoder.next_out_of_line();
5475 let handles_before = decoder.remaining_handles();
5476 if let Some((inlined, num_bytes, num_handles)) =
5477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5478 {
5479 let member_inline_size =
5480 <ConnectionOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5481 if inlined != (member_inline_size <= 4) {
5482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5483 }
5484 let inner_offset;
5485 let mut inner_depth = depth.clone();
5486 if inlined {
5487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5488 inner_offset = next_offset;
5489 } else {
5490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5491 inner_depth.increment()?;
5492 }
5493 let val_ref = self
5494 .connection_options
5495 .get_or_insert_with(|| fidl::new_empty!(ConnectionOptions, D));
5496 fidl::decode!(ConnectionOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
5497 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5498 {
5499 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5500 }
5501 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5502 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5503 }
5504 }
5505
5506 next_offset += envelope_size;
5507 _next_ordinal_to_read += 1;
5508 if next_offset >= end_offset {
5509 return Ok(());
5510 }
5511
5512 while _next_ordinal_to_read < 6 {
5514 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5515 _next_ordinal_to_read += 1;
5516 next_offset += envelope_size;
5517 }
5518
5519 let next_out_of_line = decoder.next_out_of_line();
5520 let handles_before = decoder.remaining_handles();
5521 if let Some((inlined, num_bytes, num_handles)) =
5522 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5523 {
5524 let member_inline_size =
5525 <AdvertisingProcedure as fidl::encoding::TypeMarker>::inline_size(
5526 decoder.context,
5527 );
5528 if inlined != (member_inline_size <= 4) {
5529 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5530 }
5531 let inner_offset;
5532 let mut inner_depth = depth.clone();
5533 if inlined {
5534 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5535 inner_offset = next_offset;
5536 } else {
5537 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5538 inner_depth.increment()?;
5539 }
5540 let val_ref = self
5541 .advertising_procedure
5542 .get_or_insert_with(|| fidl::new_empty!(AdvertisingProcedure, D));
5543 fidl::decode!(
5544 AdvertisingProcedure,
5545 D,
5546 val_ref,
5547 decoder,
5548 inner_offset,
5549 inner_depth
5550 )?;
5551 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5552 {
5553 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5554 }
5555 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5556 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5557 }
5558 }
5559
5560 next_offset += envelope_size;
5561 _next_ordinal_to_read += 1;
5562 if next_offset >= end_offset {
5563 return Ok(());
5564 }
5565
5566 while _next_ordinal_to_read < 7 {
5568 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5569 _next_ordinal_to_read += 1;
5570 next_offset += envelope_size;
5571 }
5572
5573 let next_out_of_line = decoder.next_out_of_line();
5574 let handles_before = decoder.remaining_handles();
5575 if let Some((inlined, num_bytes, num_handles)) =
5576 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5577 {
5578 let member_inline_size = <fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5579 if inlined != (member_inline_size <= 4) {
5580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5581 }
5582 let inner_offset;
5583 let mut inner_depth = depth.clone();
5584 if inlined {
5585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5586 inner_offset = next_offset;
5587 } else {
5588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5589 inner_depth.increment()?;
5590 }
5591 let val_ref = self.address_type.get_or_insert_with(|| {
5592 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AddressType, D)
5593 });
5594 fidl::decode!(
5595 fidl_fuchsia_bluetooth__common::AddressType,
5596 D,
5597 val_ref,
5598 decoder,
5599 inner_offset,
5600 inner_depth
5601 )?;
5602 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5603 {
5604 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5605 }
5606 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5607 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5608 }
5609 }
5610
5611 next_offset += envelope_size;
5612
5613 while next_offset < end_offset {
5615 _next_ordinal_to_read += 1;
5616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5617 next_offset += envelope_size;
5618 }
5619
5620 Ok(())
5621 }
5622 }
5623
5624 impl CentralCreateConnectedIsochronousGroupResponse {
5625 #[inline(always)]
5626 fn max_ordinal_present(&self) -> u64 {
5627 if let Some(_) = self.cig_id {
5628 return 1;
5629 }
5630 0
5631 }
5632 }
5633
5634 impl fidl::encoding::ValueTypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5635 type Borrowed<'a> = &'a Self;
5636 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5637 value
5638 }
5639 }
5640
5641 unsafe impl fidl::encoding::TypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5642 type Owned = Self;
5643
5644 #[inline(always)]
5645 fn inline_align(_context: fidl::encoding::Context) -> usize {
5646 8
5647 }
5648
5649 #[inline(always)]
5650 fn inline_size(_context: fidl::encoding::Context) -> usize {
5651 16
5652 }
5653 }
5654
5655 unsafe impl<D: fidl::encoding::ResourceDialect>
5656 fidl::encoding::Encode<CentralCreateConnectedIsochronousGroupResponse, D>
5657 for &CentralCreateConnectedIsochronousGroupResponse
5658 {
5659 unsafe fn encode(
5660 self,
5661 encoder: &mut fidl::encoding::Encoder<'_, D>,
5662 offset: usize,
5663 mut depth: fidl::encoding::Depth,
5664 ) -> fidl::Result<()> {
5665 encoder.debug_check_bounds::<CentralCreateConnectedIsochronousGroupResponse>(offset);
5666 let max_ordinal: u64 = self.max_ordinal_present();
5668 encoder.write_num(max_ordinal, offset);
5669 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5670 if max_ordinal == 0 {
5672 return Ok(());
5673 }
5674 depth.increment()?;
5675 let envelope_size = 8;
5676 let bytes_len = max_ordinal as usize * envelope_size;
5677 #[allow(unused_variables)]
5678 let offset = encoder.out_of_line_offset(bytes_len);
5679 let mut _prev_end_offset: usize = 0;
5680 if 1 > max_ordinal {
5681 return Ok(());
5682 }
5683
5684 let cur_offset: usize = (1 - 1) * envelope_size;
5687
5688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5690
5691 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5696 self.cig_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5697 encoder,
5698 offset + cur_offset,
5699 depth,
5700 )?;
5701
5702 _prev_end_offset = cur_offset + envelope_size;
5703
5704 Ok(())
5705 }
5706 }
5707
5708 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5709 for CentralCreateConnectedIsochronousGroupResponse
5710 {
5711 #[inline(always)]
5712 fn new_empty() -> Self {
5713 Self::default()
5714 }
5715
5716 unsafe fn decode(
5717 &mut self,
5718 decoder: &mut fidl::encoding::Decoder<'_, D>,
5719 offset: usize,
5720 mut depth: fidl::encoding::Depth,
5721 ) -> fidl::Result<()> {
5722 decoder.debug_check_bounds::<Self>(offset);
5723 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5724 None => return Err(fidl::Error::NotNullable),
5725 Some(len) => len,
5726 };
5727 if len == 0 {
5729 return Ok(());
5730 };
5731 depth.increment()?;
5732 let envelope_size = 8;
5733 let bytes_len = len * envelope_size;
5734 let offset = decoder.out_of_line_offset(bytes_len)?;
5735 let mut _next_ordinal_to_read = 0;
5737 let mut next_offset = offset;
5738 let end_offset = offset + bytes_len;
5739 _next_ordinal_to_read += 1;
5740 if next_offset >= end_offset {
5741 return Ok(());
5742 }
5743
5744 while _next_ordinal_to_read < 1 {
5746 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5747 _next_ordinal_to_read += 1;
5748 next_offset += envelope_size;
5749 }
5750
5751 let next_out_of_line = decoder.next_out_of_line();
5752 let handles_before = decoder.remaining_handles();
5753 if let Some((inlined, num_bytes, num_handles)) =
5754 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5755 {
5756 let member_inline_size =
5757 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5758 if inlined != (member_inline_size <= 4) {
5759 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5760 }
5761 let inner_offset;
5762 let mut inner_depth = depth.clone();
5763 if inlined {
5764 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5765 inner_offset = next_offset;
5766 } else {
5767 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5768 inner_depth.increment()?;
5769 }
5770 let val_ref = self.cig_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
5771 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5772 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5773 {
5774 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5775 }
5776 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5777 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5778 }
5779 }
5780
5781 next_offset += envelope_size;
5782
5783 while next_offset < end_offset {
5785 _next_ordinal_to_read += 1;
5786 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5787 next_offset += envelope_size;
5788 }
5789
5790 Ok(())
5791 }
5792 }
5793
5794 impl ChannelListenerRegistryListenL2capResponse {
5795 #[inline(always)]
5796 fn max_ordinal_present(&self) -> u64 {
5797 if let Some(_) = self.psm {
5798 return 1;
5799 }
5800 0
5801 }
5802 }
5803
5804 impl fidl::encoding::ValueTypeMarker for ChannelListenerRegistryListenL2capResponse {
5805 type Borrowed<'a> = &'a Self;
5806 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5807 value
5808 }
5809 }
5810
5811 unsafe impl fidl::encoding::TypeMarker for ChannelListenerRegistryListenL2capResponse {
5812 type Owned = Self;
5813
5814 #[inline(always)]
5815 fn inline_align(_context: fidl::encoding::Context) -> usize {
5816 8
5817 }
5818
5819 #[inline(always)]
5820 fn inline_size(_context: fidl::encoding::Context) -> usize {
5821 16
5822 }
5823 }
5824
5825 unsafe impl<D: fidl::encoding::ResourceDialect>
5826 fidl::encoding::Encode<ChannelListenerRegistryListenL2capResponse, D>
5827 for &ChannelListenerRegistryListenL2capResponse
5828 {
5829 unsafe fn encode(
5830 self,
5831 encoder: &mut fidl::encoding::Encoder<'_, D>,
5832 offset: usize,
5833 mut depth: fidl::encoding::Depth,
5834 ) -> fidl::Result<()> {
5835 encoder.debug_check_bounds::<ChannelListenerRegistryListenL2capResponse>(offset);
5836 let max_ordinal: u64 = self.max_ordinal_present();
5838 encoder.write_num(max_ordinal, offset);
5839 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5840 if max_ordinal == 0 {
5842 return Ok(());
5843 }
5844 depth.increment()?;
5845 let envelope_size = 8;
5846 let bytes_len = max_ordinal as usize * envelope_size;
5847 #[allow(unused_variables)]
5848 let offset = encoder.out_of_line_offset(bytes_len);
5849 let mut _prev_end_offset: usize = 0;
5850 if 1 > max_ordinal {
5851 return Ok(());
5852 }
5853
5854 let cur_offset: usize = (1 - 1) * envelope_size;
5857
5858 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5860
5861 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5866 self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5867 encoder,
5868 offset + cur_offset,
5869 depth,
5870 )?;
5871
5872 _prev_end_offset = cur_offset + envelope_size;
5873
5874 Ok(())
5875 }
5876 }
5877
5878 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5879 for ChannelListenerRegistryListenL2capResponse
5880 {
5881 #[inline(always)]
5882 fn new_empty() -> Self {
5883 Self::default()
5884 }
5885
5886 unsafe fn decode(
5887 &mut self,
5888 decoder: &mut fidl::encoding::Decoder<'_, D>,
5889 offset: usize,
5890 mut depth: fidl::encoding::Depth,
5891 ) -> fidl::Result<()> {
5892 decoder.debug_check_bounds::<Self>(offset);
5893 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5894 None => return Err(fidl::Error::NotNullable),
5895 Some(len) => len,
5896 };
5897 if len == 0 {
5899 return Ok(());
5900 };
5901 depth.increment()?;
5902 let envelope_size = 8;
5903 let bytes_len = len * envelope_size;
5904 let offset = decoder.out_of_line_offset(bytes_len)?;
5905 let mut _next_ordinal_to_read = 0;
5907 let mut next_offset = offset;
5908 let end_offset = offset + bytes_len;
5909 _next_ordinal_to_read += 1;
5910 if next_offset >= end_offset {
5911 return Ok(());
5912 }
5913
5914 while _next_ordinal_to_read < 1 {
5916 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5917 _next_ordinal_to_read += 1;
5918 next_offset += envelope_size;
5919 }
5920
5921 let next_out_of_line = decoder.next_out_of_line();
5922 let handles_before = decoder.remaining_handles();
5923 if let Some((inlined, num_bytes, num_handles)) =
5924 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5925 {
5926 let member_inline_size =
5927 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5928 if inlined != (member_inline_size <= 4) {
5929 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5930 }
5931 let inner_offset;
5932 let mut inner_depth = depth.clone();
5933 if inlined {
5934 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5935 inner_offset = next_offset;
5936 } else {
5937 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5938 inner_depth.increment()?;
5939 }
5940 let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
5941 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5942 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5943 {
5944 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5945 }
5946 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5947 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5948 }
5949 }
5950
5951 next_offset += envelope_size;
5952
5953 while next_offset < end_offset {
5955 _next_ordinal_to_read += 1;
5956 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5957 next_offset += envelope_size;
5958 }
5959
5960 Ok(())
5961 }
5962 }
5963
5964 impl CigParameters {
5965 #[inline(always)]
5966 fn max_ordinal_present(&self) -> u64 {
5967 if let Some(_) = self.max_transport_latency_p_to_c {
5968 return 6;
5969 }
5970 if let Some(_) = self.max_transport_latency_c_to_p {
5971 return 5;
5972 }
5973 if let Some(_) = self.framing {
5974 return 4;
5975 }
5976 if let Some(_) = self.packing {
5977 return 3;
5978 }
5979 if let Some(_) = self.sdu_interval_p_to_c {
5980 return 2;
5981 }
5982 if let Some(_) = self.sdu_interval_c_to_p {
5983 return 1;
5984 }
5985 0
5986 }
5987 }
5988
5989 impl fidl::encoding::ValueTypeMarker for CigParameters {
5990 type Borrowed<'a> = &'a Self;
5991 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5992 value
5993 }
5994 }
5995
5996 unsafe impl fidl::encoding::TypeMarker for CigParameters {
5997 type Owned = Self;
5998
5999 #[inline(always)]
6000 fn inline_align(_context: fidl::encoding::Context) -> usize {
6001 8
6002 }
6003
6004 #[inline(always)]
6005 fn inline_size(_context: fidl::encoding::Context) -> usize {
6006 16
6007 }
6008 }
6009
6010 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CigParameters, D>
6011 for &CigParameters
6012 {
6013 unsafe fn encode(
6014 self,
6015 encoder: &mut fidl::encoding::Encoder<'_, D>,
6016 offset: usize,
6017 mut depth: fidl::encoding::Depth,
6018 ) -> fidl::Result<()> {
6019 encoder.debug_check_bounds::<CigParameters>(offset);
6020 let max_ordinal: u64 = self.max_ordinal_present();
6022 encoder.write_num(max_ordinal, offset);
6023 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6024 if max_ordinal == 0 {
6026 return Ok(());
6027 }
6028 depth.increment()?;
6029 let envelope_size = 8;
6030 let bytes_len = max_ordinal as usize * envelope_size;
6031 #[allow(unused_variables)]
6032 let offset = encoder.out_of_line_offset(bytes_len);
6033 let mut _prev_end_offset: usize = 0;
6034 if 1 > max_ordinal {
6035 return Ok(());
6036 }
6037
6038 let cur_offset: usize = (1 - 1) * envelope_size;
6041
6042 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6044
6045 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6050 self.sdu_interval_c_to_p
6051 .as_ref()
6052 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6053 encoder,
6054 offset + cur_offset,
6055 depth,
6056 )?;
6057
6058 _prev_end_offset = cur_offset + envelope_size;
6059 if 2 > max_ordinal {
6060 return Ok(());
6061 }
6062
6063 let cur_offset: usize = (2 - 1) * envelope_size;
6066
6067 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6069
6070 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6075 self.sdu_interval_p_to_c
6076 .as_ref()
6077 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6078 encoder,
6079 offset + cur_offset,
6080 depth,
6081 )?;
6082
6083 _prev_end_offset = cur_offset + envelope_size;
6084 if 3 > max_ordinal {
6085 return Ok(());
6086 }
6087
6088 let cur_offset: usize = (3 - 1) * envelope_size;
6091
6092 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6094
6095 fidl::encoding::encode_in_envelope_optional::<CigPacking, D>(
6100 self.packing.as_ref().map(<CigPacking as fidl::encoding::ValueTypeMarker>::borrow),
6101 encoder,
6102 offset + cur_offset,
6103 depth,
6104 )?;
6105
6106 _prev_end_offset = cur_offset + envelope_size;
6107 if 4 > max_ordinal {
6108 return Ok(());
6109 }
6110
6111 let cur_offset: usize = (4 - 1) * envelope_size;
6114
6115 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6117
6118 fidl::encoding::encode_in_envelope_optional::<CigFramingOptions, D>(
6123 self.framing
6124 .as_ref()
6125 .map(<CigFramingOptions as fidl::encoding::ValueTypeMarker>::borrow),
6126 encoder,
6127 offset + cur_offset,
6128 depth,
6129 )?;
6130
6131 _prev_end_offset = cur_offset + envelope_size;
6132 if 5 > max_ordinal {
6133 return Ok(());
6134 }
6135
6136 let cur_offset: usize = (5 - 1) * envelope_size;
6139
6140 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6142
6143 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6148 self.max_transport_latency_c_to_p
6149 .as_ref()
6150 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6151 encoder,
6152 offset + cur_offset,
6153 depth,
6154 )?;
6155
6156 _prev_end_offset = cur_offset + envelope_size;
6157 if 6 > max_ordinal {
6158 return Ok(());
6159 }
6160
6161 let cur_offset: usize = (6 - 1) * envelope_size;
6164
6165 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6167
6168 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6173 self.max_transport_latency_p_to_c
6174 .as_ref()
6175 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6176 encoder,
6177 offset + cur_offset,
6178 depth,
6179 )?;
6180
6181 _prev_end_offset = cur_offset + envelope_size;
6182
6183 Ok(())
6184 }
6185 }
6186
6187 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigParameters {
6188 #[inline(always)]
6189 fn new_empty() -> Self {
6190 Self::default()
6191 }
6192
6193 unsafe fn decode(
6194 &mut self,
6195 decoder: &mut fidl::encoding::Decoder<'_, D>,
6196 offset: usize,
6197 mut depth: fidl::encoding::Depth,
6198 ) -> fidl::Result<()> {
6199 decoder.debug_check_bounds::<Self>(offset);
6200 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6201 None => return Err(fidl::Error::NotNullable),
6202 Some(len) => len,
6203 };
6204 if len == 0 {
6206 return Ok(());
6207 };
6208 depth.increment()?;
6209 let envelope_size = 8;
6210 let bytes_len = len * envelope_size;
6211 let offset = decoder.out_of_line_offset(bytes_len)?;
6212 let mut _next_ordinal_to_read = 0;
6214 let mut next_offset = offset;
6215 let end_offset = offset + bytes_len;
6216 _next_ordinal_to_read += 1;
6217 if next_offset >= end_offset {
6218 return Ok(());
6219 }
6220
6221 while _next_ordinal_to_read < 1 {
6223 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6224 _next_ordinal_to_read += 1;
6225 next_offset += envelope_size;
6226 }
6227
6228 let next_out_of_line = decoder.next_out_of_line();
6229 let handles_before = decoder.remaining_handles();
6230 if let Some((inlined, num_bytes, num_handles)) =
6231 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6232 {
6233 let member_inline_size =
6234 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6235 if inlined != (member_inline_size <= 4) {
6236 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6237 }
6238 let inner_offset;
6239 let mut inner_depth = depth.clone();
6240 if inlined {
6241 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6242 inner_offset = next_offset;
6243 } else {
6244 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6245 inner_depth.increment()?;
6246 }
6247 let val_ref =
6248 self.sdu_interval_c_to_p.get_or_insert_with(|| fidl::new_empty!(u32, D));
6249 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6250 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6251 {
6252 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6253 }
6254 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6255 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6256 }
6257 }
6258
6259 next_offset += envelope_size;
6260 _next_ordinal_to_read += 1;
6261 if next_offset >= end_offset {
6262 return Ok(());
6263 }
6264
6265 while _next_ordinal_to_read < 2 {
6267 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6268 _next_ordinal_to_read += 1;
6269 next_offset += envelope_size;
6270 }
6271
6272 let next_out_of_line = decoder.next_out_of_line();
6273 let handles_before = decoder.remaining_handles();
6274 if let Some((inlined, num_bytes, num_handles)) =
6275 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6276 {
6277 let member_inline_size =
6278 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6279 if inlined != (member_inline_size <= 4) {
6280 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6281 }
6282 let inner_offset;
6283 let mut inner_depth = depth.clone();
6284 if inlined {
6285 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6286 inner_offset = next_offset;
6287 } else {
6288 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6289 inner_depth.increment()?;
6290 }
6291 let val_ref =
6292 self.sdu_interval_p_to_c.get_or_insert_with(|| fidl::new_empty!(u32, D));
6293 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6294 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6295 {
6296 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6297 }
6298 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6299 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6300 }
6301 }
6302
6303 next_offset += envelope_size;
6304 _next_ordinal_to_read += 1;
6305 if next_offset >= end_offset {
6306 return Ok(());
6307 }
6308
6309 while _next_ordinal_to_read < 3 {
6311 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6312 _next_ordinal_to_read += 1;
6313 next_offset += envelope_size;
6314 }
6315
6316 let next_out_of_line = decoder.next_out_of_line();
6317 let handles_before = decoder.remaining_handles();
6318 if let Some((inlined, num_bytes, num_handles)) =
6319 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6320 {
6321 let member_inline_size =
6322 <CigPacking as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6323 if inlined != (member_inline_size <= 4) {
6324 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6325 }
6326 let inner_offset;
6327 let mut inner_depth = depth.clone();
6328 if inlined {
6329 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6330 inner_offset = next_offset;
6331 } else {
6332 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6333 inner_depth.increment()?;
6334 }
6335 let val_ref = self.packing.get_or_insert_with(|| fidl::new_empty!(CigPacking, D));
6336 fidl::decode!(CigPacking, D, val_ref, decoder, inner_offset, inner_depth)?;
6337 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6338 {
6339 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6340 }
6341 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6342 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6343 }
6344 }
6345
6346 next_offset += envelope_size;
6347 _next_ordinal_to_read += 1;
6348 if next_offset >= end_offset {
6349 return Ok(());
6350 }
6351
6352 while _next_ordinal_to_read < 4 {
6354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6355 _next_ordinal_to_read += 1;
6356 next_offset += envelope_size;
6357 }
6358
6359 let next_out_of_line = decoder.next_out_of_line();
6360 let handles_before = decoder.remaining_handles();
6361 if let Some((inlined, num_bytes, num_handles)) =
6362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6363 {
6364 let member_inline_size =
6365 <CigFramingOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6366 if inlined != (member_inline_size <= 4) {
6367 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6368 }
6369 let inner_offset;
6370 let mut inner_depth = depth.clone();
6371 if inlined {
6372 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6373 inner_offset = next_offset;
6374 } else {
6375 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6376 inner_depth.increment()?;
6377 }
6378 let val_ref =
6379 self.framing.get_or_insert_with(|| fidl::new_empty!(CigFramingOptions, D));
6380 fidl::decode!(CigFramingOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
6381 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6382 {
6383 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6384 }
6385 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6386 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6387 }
6388 }
6389
6390 next_offset += envelope_size;
6391 _next_ordinal_to_read += 1;
6392 if next_offset >= end_offset {
6393 return Ok(());
6394 }
6395
6396 while _next_ordinal_to_read < 5 {
6398 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6399 _next_ordinal_to_read += 1;
6400 next_offset += envelope_size;
6401 }
6402
6403 let next_out_of_line = decoder.next_out_of_line();
6404 let handles_before = decoder.remaining_handles();
6405 if let Some((inlined, num_bytes, num_handles)) =
6406 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6407 {
6408 let member_inline_size =
6409 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6410 if inlined != (member_inline_size <= 4) {
6411 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6412 }
6413 let inner_offset;
6414 let mut inner_depth = depth.clone();
6415 if inlined {
6416 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6417 inner_offset = next_offset;
6418 } else {
6419 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6420 inner_depth.increment()?;
6421 }
6422 let val_ref = self
6423 .max_transport_latency_c_to_p
6424 .get_or_insert_with(|| fidl::new_empty!(u16, D));
6425 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6426 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6427 {
6428 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6429 }
6430 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6431 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6432 }
6433 }
6434
6435 next_offset += envelope_size;
6436 _next_ordinal_to_read += 1;
6437 if next_offset >= end_offset {
6438 return Ok(());
6439 }
6440
6441 while _next_ordinal_to_read < 6 {
6443 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6444 _next_ordinal_to_read += 1;
6445 next_offset += envelope_size;
6446 }
6447
6448 let next_out_of_line = decoder.next_out_of_line();
6449 let handles_before = decoder.remaining_handles();
6450 if let Some((inlined, num_bytes, num_handles)) =
6451 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6452 {
6453 let member_inline_size =
6454 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6455 if inlined != (member_inline_size <= 4) {
6456 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6457 }
6458 let inner_offset;
6459 let mut inner_depth = depth.clone();
6460 if inlined {
6461 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6462 inner_offset = next_offset;
6463 } else {
6464 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6465 inner_depth.increment()?;
6466 }
6467 let val_ref = self
6468 .max_transport_latency_p_to_c
6469 .get_or_insert_with(|| fidl::new_empty!(u16, D));
6470 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6471 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6472 {
6473 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6474 }
6475 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6476 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6477 }
6478 }
6479
6480 next_offset += envelope_size;
6481
6482 while next_offset < end_offset {
6484 _next_ordinal_to_read += 1;
6485 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6486 next_offset += envelope_size;
6487 }
6488
6489 Ok(())
6490 }
6491 }
6492
6493 impl CisEstablishedParameters {
6494 #[inline(always)]
6495 fn max_ordinal_present(&self) -> u64 {
6496 if let Some(_) = self.peripheral_to_central_params {
6497 return 6;
6498 }
6499 if let Some(_) = self.central_to_peripheral_params {
6500 return 5;
6501 }
6502 if let Some(_) = self.iso_interval {
6503 return 4;
6504 }
6505 if let Some(_) = self.max_subevents {
6506 return 3;
6507 }
6508 if let Some(_) = self.cis_sync_delay {
6509 return 2;
6510 }
6511 if let Some(_) = self.cig_sync_delay {
6512 return 1;
6513 }
6514 0
6515 }
6516 }
6517
6518 impl fidl::encoding::ValueTypeMarker for CisEstablishedParameters {
6519 type Borrowed<'a> = &'a Self;
6520 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6521 value
6522 }
6523 }
6524
6525 unsafe impl fidl::encoding::TypeMarker for CisEstablishedParameters {
6526 type Owned = Self;
6527
6528 #[inline(always)]
6529 fn inline_align(_context: fidl::encoding::Context) -> usize {
6530 8
6531 }
6532
6533 #[inline(always)]
6534 fn inline_size(_context: fidl::encoding::Context) -> usize {
6535 16
6536 }
6537 }
6538
6539 unsafe impl<D: fidl::encoding::ResourceDialect>
6540 fidl::encoding::Encode<CisEstablishedParameters, D> for &CisEstablishedParameters
6541 {
6542 unsafe fn encode(
6543 self,
6544 encoder: &mut fidl::encoding::Encoder<'_, D>,
6545 offset: usize,
6546 mut depth: fidl::encoding::Depth,
6547 ) -> fidl::Result<()> {
6548 encoder.debug_check_bounds::<CisEstablishedParameters>(offset);
6549 let max_ordinal: u64 = self.max_ordinal_present();
6551 encoder.write_num(max_ordinal, offset);
6552 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6553 if max_ordinal == 0 {
6555 return Ok(());
6556 }
6557 depth.increment()?;
6558 let envelope_size = 8;
6559 let bytes_len = max_ordinal as usize * envelope_size;
6560 #[allow(unused_variables)]
6561 let offset = encoder.out_of_line_offset(bytes_len);
6562 let mut _prev_end_offset: usize = 0;
6563 if 1 > max_ordinal {
6564 return Ok(());
6565 }
6566
6567 let cur_offset: usize = (1 - 1) * envelope_size;
6570
6571 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6573
6574 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6579 self.cig_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6580 encoder,
6581 offset + cur_offset,
6582 depth,
6583 )?;
6584
6585 _prev_end_offset = cur_offset + envelope_size;
6586 if 2 > max_ordinal {
6587 return Ok(());
6588 }
6589
6590 let cur_offset: usize = (2 - 1) * envelope_size;
6593
6594 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6596
6597 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6602 self.cis_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6603 encoder,
6604 offset + cur_offset,
6605 depth,
6606 )?;
6607
6608 _prev_end_offset = cur_offset + envelope_size;
6609 if 3 > max_ordinal {
6610 return Ok(());
6611 }
6612
6613 let cur_offset: usize = (3 - 1) * envelope_size;
6616
6617 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6619
6620 fidl::encoding::encode_in_envelope_optional::<u8, D>(
6625 self.max_subevents.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
6626 encoder,
6627 offset + cur_offset,
6628 depth,
6629 )?;
6630
6631 _prev_end_offset = cur_offset + envelope_size;
6632 if 4 > max_ordinal {
6633 return Ok(());
6634 }
6635
6636 let cur_offset: usize = (4 - 1) * envelope_size;
6639
6640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6642
6643 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6648 self.iso_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6649 encoder,
6650 offset + cur_offset,
6651 depth,
6652 )?;
6653
6654 _prev_end_offset = cur_offset + envelope_size;
6655 if 5 > max_ordinal {
6656 return Ok(());
6657 }
6658
6659 let cur_offset: usize = (5 - 1) * envelope_size;
6662
6663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6665
6666 fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6671 self.central_to_peripheral_params
6672 .as_ref()
6673 .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6674 encoder,
6675 offset + cur_offset,
6676 depth,
6677 )?;
6678
6679 _prev_end_offset = cur_offset + envelope_size;
6680 if 6 > max_ordinal {
6681 return Ok(());
6682 }
6683
6684 let cur_offset: usize = (6 - 1) * envelope_size;
6687
6688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6690
6691 fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6696 self.peripheral_to_central_params
6697 .as_ref()
6698 .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6699 encoder,
6700 offset + cur_offset,
6701 depth,
6702 )?;
6703
6704 _prev_end_offset = cur_offset + envelope_size;
6705
6706 Ok(())
6707 }
6708 }
6709
6710 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6711 for CisEstablishedParameters
6712 {
6713 #[inline(always)]
6714 fn new_empty() -> Self {
6715 Self::default()
6716 }
6717
6718 unsafe fn decode(
6719 &mut self,
6720 decoder: &mut fidl::encoding::Decoder<'_, D>,
6721 offset: usize,
6722 mut depth: fidl::encoding::Depth,
6723 ) -> fidl::Result<()> {
6724 decoder.debug_check_bounds::<Self>(offset);
6725 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6726 None => return Err(fidl::Error::NotNullable),
6727 Some(len) => len,
6728 };
6729 if len == 0 {
6731 return Ok(());
6732 };
6733 depth.increment()?;
6734 let envelope_size = 8;
6735 let bytes_len = len * envelope_size;
6736 let offset = decoder.out_of_line_offset(bytes_len)?;
6737 let mut _next_ordinal_to_read = 0;
6739 let mut next_offset = offset;
6740 let end_offset = offset + bytes_len;
6741 _next_ordinal_to_read += 1;
6742 if next_offset >= end_offset {
6743 return Ok(());
6744 }
6745
6746 while _next_ordinal_to_read < 1 {
6748 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6749 _next_ordinal_to_read += 1;
6750 next_offset += envelope_size;
6751 }
6752
6753 let next_out_of_line = decoder.next_out_of_line();
6754 let handles_before = decoder.remaining_handles();
6755 if let Some((inlined, num_bytes, num_handles)) =
6756 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6757 {
6758 let member_inline_size =
6759 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6760 if inlined != (member_inline_size <= 4) {
6761 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6762 }
6763 let inner_offset;
6764 let mut inner_depth = depth.clone();
6765 if inlined {
6766 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6767 inner_offset = next_offset;
6768 } else {
6769 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6770 inner_depth.increment()?;
6771 }
6772 let val_ref = self.cig_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6773 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6774 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6775 {
6776 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6777 }
6778 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6779 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6780 }
6781 }
6782
6783 next_offset += envelope_size;
6784 _next_ordinal_to_read += 1;
6785 if next_offset >= end_offset {
6786 return Ok(());
6787 }
6788
6789 while _next_ordinal_to_read < 2 {
6791 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6792 _next_ordinal_to_read += 1;
6793 next_offset += envelope_size;
6794 }
6795
6796 let next_out_of_line = decoder.next_out_of_line();
6797 let handles_before = decoder.remaining_handles();
6798 if let Some((inlined, num_bytes, num_handles)) =
6799 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6800 {
6801 let member_inline_size =
6802 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6803 if inlined != (member_inline_size <= 4) {
6804 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6805 }
6806 let inner_offset;
6807 let mut inner_depth = depth.clone();
6808 if inlined {
6809 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6810 inner_offset = next_offset;
6811 } else {
6812 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6813 inner_depth.increment()?;
6814 }
6815 let val_ref = self.cis_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6816 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6817 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6818 {
6819 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6820 }
6821 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6822 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6823 }
6824 }
6825
6826 next_offset += envelope_size;
6827 _next_ordinal_to_read += 1;
6828 if next_offset >= end_offset {
6829 return Ok(());
6830 }
6831
6832 while _next_ordinal_to_read < 3 {
6834 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6835 _next_ordinal_to_read += 1;
6836 next_offset += envelope_size;
6837 }
6838
6839 let next_out_of_line = decoder.next_out_of_line();
6840 let handles_before = decoder.remaining_handles();
6841 if let Some((inlined, num_bytes, num_handles)) =
6842 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6843 {
6844 let member_inline_size =
6845 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6846 if inlined != (member_inline_size <= 4) {
6847 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6848 }
6849 let inner_offset;
6850 let mut inner_depth = depth.clone();
6851 if inlined {
6852 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6853 inner_offset = next_offset;
6854 } else {
6855 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6856 inner_depth.increment()?;
6857 }
6858 let val_ref = self.max_subevents.get_or_insert_with(|| fidl::new_empty!(u8, D));
6859 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6860 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6861 {
6862 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6863 }
6864 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6865 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6866 }
6867 }
6868
6869 next_offset += envelope_size;
6870 _next_ordinal_to_read += 1;
6871 if next_offset >= end_offset {
6872 return Ok(());
6873 }
6874
6875 while _next_ordinal_to_read < 4 {
6877 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6878 _next_ordinal_to_read += 1;
6879 next_offset += envelope_size;
6880 }
6881
6882 let next_out_of_line = decoder.next_out_of_line();
6883 let handles_before = decoder.remaining_handles();
6884 if let Some((inlined, num_bytes, num_handles)) =
6885 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6886 {
6887 let member_inline_size =
6888 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6889 if inlined != (member_inline_size <= 4) {
6890 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6891 }
6892 let inner_offset;
6893 let mut inner_depth = depth.clone();
6894 if inlined {
6895 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6896 inner_offset = next_offset;
6897 } else {
6898 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6899 inner_depth.increment()?;
6900 }
6901 let val_ref = self.iso_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
6902 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6903 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6904 {
6905 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6906 }
6907 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6908 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6909 }
6910 }
6911
6912 next_offset += envelope_size;
6913 _next_ordinal_to_read += 1;
6914 if next_offset >= end_offset {
6915 return Ok(());
6916 }
6917
6918 while _next_ordinal_to_read < 5 {
6920 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6921 _next_ordinal_to_read += 1;
6922 next_offset += envelope_size;
6923 }
6924
6925 let next_out_of_line = decoder.next_out_of_line();
6926 let handles_before = decoder.remaining_handles();
6927 if let Some((inlined, num_bytes, num_handles)) =
6928 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6929 {
6930 let member_inline_size =
6931 <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
6932 decoder.context,
6933 );
6934 if inlined != (member_inline_size <= 4) {
6935 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6936 }
6937 let inner_offset;
6938 let mut inner_depth = depth.clone();
6939 if inlined {
6940 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6941 inner_offset = next_offset;
6942 } else {
6943 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6944 inner_depth.increment()?;
6945 }
6946 let val_ref = self
6947 .central_to_peripheral_params
6948 .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
6949 fidl::decode!(
6950 CisUnidirectionalParams,
6951 D,
6952 val_ref,
6953 decoder,
6954 inner_offset,
6955 inner_depth
6956 )?;
6957 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6958 {
6959 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6960 }
6961 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6962 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6963 }
6964 }
6965
6966 next_offset += envelope_size;
6967 _next_ordinal_to_read += 1;
6968 if next_offset >= end_offset {
6969 return Ok(());
6970 }
6971
6972 while _next_ordinal_to_read < 6 {
6974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6975 _next_ordinal_to_read += 1;
6976 next_offset += envelope_size;
6977 }
6978
6979 let next_out_of_line = decoder.next_out_of_line();
6980 let handles_before = decoder.remaining_handles();
6981 if let Some((inlined, num_bytes, num_handles)) =
6982 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6983 {
6984 let member_inline_size =
6985 <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
6986 decoder.context,
6987 );
6988 if inlined != (member_inline_size <= 4) {
6989 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6990 }
6991 let inner_offset;
6992 let mut inner_depth = depth.clone();
6993 if inlined {
6994 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6995 inner_offset = next_offset;
6996 } else {
6997 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6998 inner_depth.increment()?;
6999 }
7000 let val_ref = self
7001 .peripheral_to_central_params
7002 .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7003 fidl::decode!(
7004 CisUnidirectionalParams,
7005 D,
7006 val_ref,
7007 decoder,
7008 inner_offset,
7009 inner_depth
7010 )?;
7011 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7012 {
7013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7014 }
7015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7017 }
7018 }
7019
7020 next_offset += envelope_size;
7021
7022 while next_offset < end_offset {
7024 _next_ordinal_to_read += 1;
7025 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7026 next_offset += envelope_size;
7027 }
7028
7029 Ok(())
7030 }
7031 }
7032
7033 impl CisParameters {
7034 #[inline(always)]
7035 fn max_ordinal_present(&self) -> u64 {
7036 if let Some(_) = self.id {
7037 return 2;
7038 }
7039 if let Some(_) = self.cis_id {
7040 return 1;
7041 }
7042 0
7043 }
7044 }
7045
7046 impl fidl::encoding::ValueTypeMarker for CisParameters {
7047 type Borrowed<'a> = &'a Self;
7048 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7049 value
7050 }
7051 }
7052
7053 unsafe impl fidl::encoding::TypeMarker for CisParameters {
7054 type Owned = Self;
7055
7056 #[inline(always)]
7057 fn inline_align(_context: fidl::encoding::Context) -> usize {
7058 8
7059 }
7060
7061 #[inline(always)]
7062 fn inline_size(_context: fidl::encoding::Context) -> usize {
7063 16
7064 }
7065 }
7066
7067 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CisParameters, D>
7068 for &CisParameters
7069 {
7070 unsafe fn encode(
7071 self,
7072 encoder: &mut fidl::encoding::Encoder<'_, D>,
7073 offset: usize,
7074 mut depth: fidl::encoding::Depth,
7075 ) -> fidl::Result<()> {
7076 encoder.debug_check_bounds::<CisParameters>(offset);
7077 let max_ordinal: u64 = self.max_ordinal_present();
7079 encoder.write_num(max_ordinal, offset);
7080 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7081 if max_ordinal == 0 {
7083 return Ok(());
7084 }
7085 depth.increment()?;
7086 let envelope_size = 8;
7087 let bytes_len = max_ordinal as usize * envelope_size;
7088 #[allow(unused_variables)]
7089 let offset = encoder.out_of_line_offset(bytes_len);
7090 let mut _prev_end_offset: usize = 0;
7091 if 1 > max_ordinal {
7092 return Ok(());
7093 }
7094
7095 let cur_offset: usize = (1 - 1) * envelope_size;
7098
7099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7101
7102 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7107 self.cis_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7108 encoder,
7109 offset + cur_offset,
7110 depth,
7111 )?;
7112
7113 _prev_end_offset = cur_offset + envelope_size;
7114 if 2 > max_ordinal {
7115 return Ok(());
7116 }
7117
7118 let cur_offset: usize = (2 - 1) * envelope_size;
7121
7122 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7124
7125 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
7130 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
7131 encoder, offset + cur_offset, depth
7132 )?;
7133
7134 _prev_end_offset = cur_offset + envelope_size;
7135
7136 Ok(())
7137 }
7138 }
7139
7140 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CisParameters {
7141 #[inline(always)]
7142 fn new_empty() -> Self {
7143 Self::default()
7144 }
7145
7146 unsafe fn decode(
7147 &mut self,
7148 decoder: &mut fidl::encoding::Decoder<'_, D>,
7149 offset: usize,
7150 mut depth: fidl::encoding::Depth,
7151 ) -> fidl::Result<()> {
7152 decoder.debug_check_bounds::<Self>(offset);
7153 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7154 None => return Err(fidl::Error::NotNullable),
7155 Some(len) => len,
7156 };
7157 if len == 0 {
7159 return Ok(());
7160 };
7161 depth.increment()?;
7162 let envelope_size = 8;
7163 let bytes_len = len * envelope_size;
7164 let offset = decoder.out_of_line_offset(bytes_len)?;
7165 let mut _next_ordinal_to_read = 0;
7167 let mut next_offset = offset;
7168 let end_offset = offset + bytes_len;
7169 _next_ordinal_to_read += 1;
7170 if next_offset >= end_offset {
7171 return Ok(());
7172 }
7173
7174 while _next_ordinal_to_read < 1 {
7176 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7177 _next_ordinal_to_read += 1;
7178 next_offset += envelope_size;
7179 }
7180
7181 let next_out_of_line = decoder.next_out_of_line();
7182 let handles_before = decoder.remaining_handles();
7183 if let Some((inlined, num_bytes, num_handles)) =
7184 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7185 {
7186 let member_inline_size =
7187 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7188 if inlined != (member_inline_size <= 4) {
7189 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7190 }
7191 let inner_offset;
7192 let mut inner_depth = depth.clone();
7193 if inlined {
7194 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7195 inner_offset = next_offset;
7196 } else {
7197 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7198 inner_depth.increment()?;
7199 }
7200 let val_ref = self.cis_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7201 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7202 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7203 {
7204 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7205 }
7206 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7207 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7208 }
7209 }
7210
7211 next_offset += envelope_size;
7212 _next_ordinal_to_read += 1;
7213 if next_offset >= end_offset {
7214 return Ok(());
7215 }
7216
7217 while _next_ordinal_to_read < 2 {
7219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7220 _next_ordinal_to_read += 1;
7221 next_offset += envelope_size;
7222 }
7223
7224 let next_out_of_line = decoder.next_out_of_line();
7225 let handles_before = decoder.remaining_handles();
7226 if let Some((inlined, num_bytes, num_handles)) =
7227 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7228 {
7229 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7230 if inlined != (member_inline_size <= 4) {
7231 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7232 }
7233 let inner_offset;
7234 let mut inner_depth = depth.clone();
7235 if inlined {
7236 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7237 inner_offset = next_offset;
7238 } else {
7239 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7240 inner_depth.increment()?;
7241 }
7242 let val_ref = self.id.get_or_insert_with(|| {
7243 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
7244 });
7245 fidl::decode!(
7246 fidl_fuchsia_bluetooth__common::PeerId,
7247 D,
7248 val_ref,
7249 decoder,
7250 inner_offset,
7251 inner_depth
7252 )?;
7253 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7254 {
7255 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7256 }
7257 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7258 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7259 }
7260 }
7261
7262 next_offset += envelope_size;
7263
7264 while next_offset < end_offset {
7266 _next_ordinal_to_read += 1;
7267 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7268 next_offset += envelope_size;
7269 }
7270
7271 Ok(())
7272 }
7273 }
7274
7275 impl CisUnidirectionalParams {
7276 #[inline(always)]
7277 fn max_ordinal_present(&self) -> u64 {
7278 if let Some(_) = self.flush_timeout {
7279 return 3;
7280 }
7281 if let Some(_) = self.burst_number {
7282 return 2;
7283 }
7284 if let Some(_) = self.transport_latency {
7285 return 1;
7286 }
7287 0
7288 }
7289 }
7290
7291 impl fidl::encoding::ValueTypeMarker for CisUnidirectionalParams {
7292 type Borrowed<'a> = &'a Self;
7293 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7294 value
7295 }
7296 }
7297
7298 unsafe impl fidl::encoding::TypeMarker for CisUnidirectionalParams {
7299 type Owned = Self;
7300
7301 #[inline(always)]
7302 fn inline_align(_context: fidl::encoding::Context) -> usize {
7303 8
7304 }
7305
7306 #[inline(always)]
7307 fn inline_size(_context: fidl::encoding::Context) -> usize {
7308 16
7309 }
7310 }
7311
7312 unsafe impl<D: fidl::encoding::ResourceDialect>
7313 fidl::encoding::Encode<CisUnidirectionalParams, D> for &CisUnidirectionalParams
7314 {
7315 unsafe fn encode(
7316 self,
7317 encoder: &mut fidl::encoding::Encoder<'_, D>,
7318 offset: usize,
7319 mut depth: fidl::encoding::Depth,
7320 ) -> fidl::Result<()> {
7321 encoder.debug_check_bounds::<CisUnidirectionalParams>(offset);
7322 let max_ordinal: u64 = self.max_ordinal_present();
7324 encoder.write_num(max_ordinal, offset);
7325 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7326 if max_ordinal == 0 {
7328 return Ok(());
7329 }
7330 depth.increment()?;
7331 let envelope_size = 8;
7332 let bytes_len = max_ordinal as usize * envelope_size;
7333 #[allow(unused_variables)]
7334 let offset = encoder.out_of_line_offset(bytes_len);
7335 let mut _prev_end_offset: usize = 0;
7336 if 1 > max_ordinal {
7337 return Ok(());
7338 }
7339
7340 let cur_offset: usize = (1 - 1) * envelope_size;
7343
7344 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7346
7347 fidl::encoding::encode_in_envelope_optional::<i64, D>(
7352 self.transport_latency
7353 .as_ref()
7354 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7355 encoder,
7356 offset + cur_offset,
7357 depth,
7358 )?;
7359
7360 _prev_end_offset = cur_offset + envelope_size;
7361 if 2 > max_ordinal {
7362 return Ok(());
7363 }
7364
7365 let cur_offset: usize = (2 - 1) * envelope_size;
7368
7369 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7371
7372 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7377 self.burst_number.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7378 encoder,
7379 offset + cur_offset,
7380 depth,
7381 )?;
7382
7383 _prev_end_offset = cur_offset + envelope_size;
7384 if 3 > max_ordinal {
7385 return Ok(());
7386 }
7387
7388 let cur_offset: usize = (3 - 1) * envelope_size;
7391
7392 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7394
7395 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7400 self.flush_timeout.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7401 encoder,
7402 offset + cur_offset,
7403 depth,
7404 )?;
7405
7406 _prev_end_offset = cur_offset + envelope_size;
7407
7408 Ok(())
7409 }
7410 }
7411
7412 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7413 for CisUnidirectionalParams
7414 {
7415 #[inline(always)]
7416 fn new_empty() -> Self {
7417 Self::default()
7418 }
7419
7420 unsafe fn decode(
7421 &mut self,
7422 decoder: &mut fidl::encoding::Decoder<'_, D>,
7423 offset: usize,
7424 mut depth: fidl::encoding::Depth,
7425 ) -> fidl::Result<()> {
7426 decoder.debug_check_bounds::<Self>(offset);
7427 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7428 None => return Err(fidl::Error::NotNullable),
7429 Some(len) => len,
7430 };
7431 if len == 0 {
7433 return Ok(());
7434 };
7435 depth.increment()?;
7436 let envelope_size = 8;
7437 let bytes_len = len * envelope_size;
7438 let offset = decoder.out_of_line_offset(bytes_len)?;
7439 let mut _next_ordinal_to_read = 0;
7441 let mut next_offset = offset;
7442 let end_offset = offset + bytes_len;
7443 _next_ordinal_to_read += 1;
7444 if next_offset >= end_offset {
7445 return Ok(());
7446 }
7447
7448 while _next_ordinal_to_read < 1 {
7450 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7451 _next_ordinal_to_read += 1;
7452 next_offset += envelope_size;
7453 }
7454
7455 let next_out_of_line = decoder.next_out_of_line();
7456 let handles_before = decoder.remaining_handles();
7457 if let Some((inlined, num_bytes, num_handles)) =
7458 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7459 {
7460 let member_inline_size =
7461 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7462 if inlined != (member_inline_size <= 4) {
7463 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7464 }
7465 let inner_offset;
7466 let mut inner_depth = depth.clone();
7467 if inlined {
7468 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7469 inner_offset = next_offset;
7470 } else {
7471 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7472 inner_depth.increment()?;
7473 }
7474 let val_ref =
7475 self.transport_latency.get_or_insert_with(|| fidl::new_empty!(i64, D));
7476 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7477 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7478 {
7479 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7480 }
7481 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7482 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7483 }
7484 }
7485
7486 next_offset += envelope_size;
7487 _next_ordinal_to_read += 1;
7488 if next_offset >= end_offset {
7489 return Ok(());
7490 }
7491
7492 while _next_ordinal_to_read < 2 {
7494 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7495 _next_ordinal_to_read += 1;
7496 next_offset += envelope_size;
7497 }
7498
7499 let next_out_of_line = decoder.next_out_of_line();
7500 let handles_before = decoder.remaining_handles();
7501 if let Some((inlined, num_bytes, num_handles)) =
7502 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7503 {
7504 let member_inline_size =
7505 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7506 if inlined != (member_inline_size <= 4) {
7507 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7508 }
7509 let inner_offset;
7510 let mut inner_depth = depth.clone();
7511 if inlined {
7512 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7513 inner_offset = next_offset;
7514 } else {
7515 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7516 inner_depth.increment()?;
7517 }
7518 let val_ref = self.burst_number.get_or_insert_with(|| fidl::new_empty!(u8, D));
7519 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7520 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7521 {
7522 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7523 }
7524 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7525 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7526 }
7527 }
7528
7529 next_offset += envelope_size;
7530 _next_ordinal_to_read += 1;
7531 if next_offset >= end_offset {
7532 return Ok(());
7533 }
7534
7535 while _next_ordinal_to_read < 3 {
7537 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7538 _next_ordinal_to_read += 1;
7539 next_offset += envelope_size;
7540 }
7541
7542 let next_out_of_line = decoder.next_out_of_line();
7543 let handles_before = decoder.remaining_handles();
7544 if let Some((inlined, num_bytes, num_handles)) =
7545 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7546 {
7547 let member_inline_size =
7548 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7549 if inlined != (member_inline_size <= 4) {
7550 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7551 }
7552 let inner_offset;
7553 let mut inner_depth = depth.clone();
7554 if inlined {
7555 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7556 inner_offset = next_offset;
7557 } else {
7558 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7559 inner_depth.increment()?;
7560 }
7561 let val_ref = self.flush_timeout.get_or_insert_with(|| fidl::new_empty!(u8, D));
7562 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7563 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7564 {
7565 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7566 }
7567 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7568 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7569 }
7570 }
7571
7572 next_offset += envelope_size;
7573
7574 while next_offset < end_offset {
7576 _next_ordinal_to_read += 1;
7577 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7578 next_offset += envelope_size;
7579 }
7580
7581 Ok(())
7582 }
7583 }
7584
7585 impl CodecDelayGetCodecLocalDelayRangeRequest {
7586 #[inline(always)]
7587 fn max_ordinal_present(&self) -> u64 {
7588 if let Some(_) = self.codec_attributes {
7589 return 3;
7590 }
7591 if let Some(_) = self.data_direction {
7592 return 2;
7593 }
7594 if let Some(_) = self.logical_transport_type {
7595 return 1;
7596 }
7597 0
7598 }
7599 }
7600
7601 impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7602 type Borrowed<'a> = &'a Self;
7603 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7604 value
7605 }
7606 }
7607
7608 unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7609 type Owned = Self;
7610
7611 #[inline(always)]
7612 fn inline_align(_context: fidl::encoding::Context) -> usize {
7613 8
7614 }
7615
7616 #[inline(always)]
7617 fn inline_size(_context: fidl::encoding::Context) -> usize {
7618 16
7619 }
7620 }
7621
7622 unsafe impl<D: fidl::encoding::ResourceDialect>
7623 fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeRequest, D>
7624 for &CodecDelayGetCodecLocalDelayRangeRequest
7625 {
7626 unsafe fn encode(
7627 self,
7628 encoder: &mut fidl::encoding::Encoder<'_, D>,
7629 offset: usize,
7630 mut depth: fidl::encoding::Depth,
7631 ) -> fidl::Result<()> {
7632 encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeRequest>(offset);
7633 let max_ordinal: u64 = self.max_ordinal_present();
7635 encoder.write_num(max_ordinal, offset);
7636 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7637 if max_ordinal == 0 {
7639 return Ok(());
7640 }
7641 depth.increment()?;
7642 let envelope_size = 8;
7643 let bytes_len = max_ordinal as usize * envelope_size;
7644 #[allow(unused_variables)]
7645 let offset = encoder.out_of_line_offset(bytes_len);
7646 let mut _prev_end_offset: usize = 0;
7647 if 1 > max_ordinal {
7648 return Ok(());
7649 }
7650
7651 let cur_offset: usize = (1 - 1) * envelope_size;
7654
7655 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7657
7658 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::LogicalTransportType, D>(
7663 self.logical_transport_type.as_ref().map(<fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::ValueTypeMarker>::borrow),
7664 encoder, offset + cur_offset, depth
7665 )?;
7666
7667 _prev_end_offset = cur_offset + envelope_size;
7668 if 2 > max_ordinal {
7669 return Ok(());
7670 }
7671
7672 let cur_offset: usize = (2 - 1) * envelope_size;
7675
7676 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7678
7679 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
7684 self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
7685 encoder, offset + cur_offset, depth
7686 )?;
7687
7688 _prev_end_offset = cur_offset + envelope_size;
7689 if 3 > max_ordinal {
7690 return Ok(());
7691 }
7692
7693 let cur_offset: usize = (3 - 1) * envelope_size;
7696
7697 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7699
7700 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
7705 self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
7706 encoder, offset + cur_offset, depth
7707 )?;
7708
7709 _prev_end_offset = cur_offset + envelope_size;
7710
7711 Ok(())
7712 }
7713 }
7714
7715 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7716 for CodecDelayGetCodecLocalDelayRangeRequest
7717 {
7718 #[inline(always)]
7719 fn new_empty() -> Self {
7720 Self::default()
7721 }
7722
7723 unsafe fn decode(
7724 &mut self,
7725 decoder: &mut fidl::encoding::Decoder<'_, D>,
7726 offset: usize,
7727 mut depth: fidl::encoding::Depth,
7728 ) -> fidl::Result<()> {
7729 decoder.debug_check_bounds::<Self>(offset);
7730 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7731 None => return Err(fidl::Error::NotNullable),
7732 Some(len) => len,
7733 };
7734 if len == 0 {
7736 return Ok(());
7737 };
7738 depth.increment()?;
7739 let envelope_size = 8;
7740 let bytes_len = len * envelope_size;
7741 let offset = decoder.out_of_line_offset(bytes_len)?;
7742 let mut _next_ordinal_to_read = 0;
7744 let mut next_offset = offset;
7745 let end_offset = offset + bytes_len;
7746 _next_ordinal_to_read += 1;
7747 if next_offset >= end_offset {
7748 return Ok(());
7749 }
7750
7751 while _next_ordinal_to_read < 1 {
7753 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7754 _next_ordinal_to_read += 1;
7755 next_offset += envelope_size;
7756 }
7757
7758 let next_out_of_line = decoder.next_out_of_line();
7759 let handles_before = decoder.remaining_handles();
7760 if let Some((inlined, num_bytes, num_handles)) =
7761 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7762 {
7763 let member_inline_size = <fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7764 if inlined != (member_inline_size <= 4) {
7765 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7766 }
7767 let inner_offset;
7768 let mut inner_depth = depth.clone();
7769 if inlined {
7770 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7771 inner_offset = next_offset;
7772 } else {
7773 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7774 inner_depth.increment()?;
7775 }
7776 let val_ref = self.logical_transport_type.get_or_insert_with(|| {
7777 fidl::new_empty!(fidl_fuchsia_bluetooth__common::LogicalTransportType, D)
7778 });
7779 fidl::decode!(
7780 fidl_fuchsia_bluetooth__common::LogicalTransportType,
7781 D,
7782 val_ref,
7783 decoder,
7784 inner_offset,
7785 inner_depth
7786 )?;
7787 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7788 {
7789 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7790 }
7791 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7792 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7793 }
7794 }
7795
7796 next_offset += envelope_size;
7797 _next_ordinal_to_read += 1;
7798 if next_offset >= end_offset {
7799 return Ok(());
7800 }
7801
7802 while _next_ordinal_to_read < 2 {
7804 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7805 _next_ordinal_to_read += 1;
7806 next_offset += envelope_size;
7807 }
7808
7809 let next_out_of_line = decoder.next_out_of_line();
7810 let handles_before = decoder.remaining_handles();
7811 if let Some((inlined, num_bytes, num_handles)) =
7812 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7813 {
7814 let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7815 if inlined != (member_inline_size <= 4) {
7816 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7817 }
7818 let inner_offset;
7819 let mut inner_depth = depth.clone();
7820 if inlined {
7821 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7822 inner_offset = next_offset;
7823 } else {
7824 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7825 inner_depth.increment()?;
7826 }
7827 let val_ref = self.data_direction.get_or_insert_with(|| {
7828 fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
7829 });
7830 fidl::decode!(
7831 fidl_fuchsia_bluetooth__common::DataDirection,
7832 D,
7833 val_ref,
7834 decoder,
7835 inner_offset,
7836 inner_depth
7837 )?;
7838 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7839 {
7840 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7841 }
7842 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7843 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7844 }
7845 }
7846
7847 next_offset += envelope_size;
7848 _next_ordinal_to_read += 1;
7849 if next_offset >= end_offset {
7850 return Ok(());
7851 }
7852
7853 while _next_ordinal_to_read < 3 {
7855 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7856 _next_ordinal_to_read += 1;
7857 next_offset += envelope_size;
7858 }
7859
7860 let next_out_of_line = decoder.next_out_of_line();
7861 let handles_before = decoder.remaining_handles();
7862 if let Some((inlined, num_bytes, num_handles)) =
7863 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7864 {
7865 let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7866 if inlined != (member_inline_size <= 4) {
7867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7868 }
7869 let inner_offset;
7870 let mut inner_depth = depth.clone();
7871 if inlined {
7872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7873 inner_offset = next_offset;
7874 } else {
7875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7876 inner_depth.increment()?;
7877 }
7878 let val_ref = self.codec_attributes.get_or_insert_with(|| {
7879 fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
7880 });
7881 fidl::decode!(
7882 fidl_fuchsia_bluetooth__common::CodecAttributes,
7883 D,
7884 val_ref,
7885 decoder,
7886 inner_offset,
7887 inner_depth
7888 )?;
7889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7890 {
7891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7892 }
7893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7895 }
7896 }
7897
7898 next_offset += envelope_size;
7899
7900 while next_offset < end_offset {
7902 _next_ordinal_to_read += 1;
7903 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7904 next_offset += envelope_size;
7905 }
7906
7907 Ok(())
7908 }
7909 }
7910
7911 impl CodecDelayGetCodecLocalDelayRangeResponse {
7912 #[inline(always)]
7913 fn max_ordinal_present(&self) -> u64 {
7914 if let Some(_) = self.max_controller_delay {
7915 return 2;
7916 }
7917 if let Some(_) = self.min_controller_delay {
7918 return 1;
7919 }
7920 0
7921 }
7922 }
7923
7924 impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7925 type Borrowed<'a> = &'a Self;
7926 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7927 value
7928 }
7929 }
7930
7931 unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7932 type Owned = Self;
7933
7934 #[inline(always)]
7935 fn inline_align(_context: fidl::encoding::Context) -> usize {
7936 8
7937 }
7938
7939 #[inline(always)]
7940 fn inline_size(_context: fidl::encoding::Context) -> usize {
7941 16
7942 }
7943 }
7944
7945 unsafe impl<D: fidl::encoding::ResourceDialect>
7946 fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeResponse, D>
7947 for &CodecDelayGetCodecLocalDelayRangeResponse
7948 {
7949 unsafe fn encode(
7950 self,
7951 encoder: &mut fidl::encoding::Encoder<'_, D>,
7952 offset: usize,
7953 mut depth: fidl::encoding::Depth,
7954 ) -> fidl::Result<()> {
7955 encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeResponse>(offset);
7956 let max_ordinal: u64 = self.max_ordinal_present();
7958 encoder.write_num(max_ordinal, offset);
7959 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7960 if max_ordinal == 0 {
7962 return Ok(());
7963 }
7964 depth.increment()?;
7965 let envelope_size = 8;
7966 let bytes_len = max_ordinal as usize * envelope_size;
7967 #[allow(unused_variables)]
7968 let offset = encoder.out_of_line_offset(bytes_len);
7969 let mut _prev_end_offset: usize = 0;
7970 if 1 > max_ordinal {
7971 return Ok(());
7972 }
7973
7974 let cur_offset: usize = (1 - 1) * envelope_size;
7977
7978 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7980
7981 fidl::encoding::encode_in_envelope_optional::<i64, D>(
7986 self.min_controller_delay
7987 .as_ref()
7988 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7989 encoder,
7990 offset + cur_offset,
7991 depth,
7992 )?;
7993
7994 _prev_end_offset = cur_offset + envelope_size;
7995 if 2 > max_ordinal {
7996 return Ok(());
7997 }
7998
7999 let cur_offset: usize = (2 - 1) * envelope_size;
8002
8003 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8005
8006 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8011 self.max_controller_delay
8012 .as_ref()
8013 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8014 encoder,
8015 offset + cur_offset,
8016 depth,
8017 )?;
8018
8019 _prev_end_offset = cur_offset + envelope_size;
8020
8021 Ok(())
8022 }
8023 }
8024
8025 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8026 for CodecDelayGetCodecLocalDelayRangeResponse
8027 {
8028 #[inline(always)]
8029 fn new_empty() -> Self {
8030 Self::default()
8031 }
8032
8033 unsafe fn decode(
8034 &mut self,
8035 decoder: &mut fidl::encoding::Decoder<'_, D>,
8036 offset: usize,
8037 mut depth: fidl::encoding::Depth,
8038 ) -> fidl::Result<()> {
8039 decoder.debug_check_bounds::<Self>(offset);
8040 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8041 None => return Err(fidl::Error::NotNullable),
8042 Some(len) => len,
8043 };
8044 if len == 0 {
8046 return Ok(());
8047 };
8048 depth.increment()?;
8049 let envelope_size = 8;
8050 let bytes_len = len * envelope_size;
8051 let offset = decoder.out_of_line_offset(bytes_len)?;
8052 let mut _next_ordinal_to_read = 0;
8054 let mut next_offset = offset;
8055 let end_offset = offset + bytes_len;
8056 _next_ordinal_to_read += 1;
8057 if next_offset >= end_offset {
8058 return Ok(());
8059 }
8060
8061 while _next_ordinal_to_read < 1 {
8063 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8064 _next_ordinal_to_read += 1;
8065 next_offset += envelope_size;
8066 }
8067
8068 let next_out_of_line = decoder.next_out_of_line();
8069 let handles_before = decoder.remaining_handles();
8070 if let Some((inlined, num_bytes, num_handles)) =
8071 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8072 {
8073 let member_inline_size =
8074 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8075 if inlined != (member_inline_size <= 4) {
8076 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8077 }
8078 let inner_offset;
8079 let mut inner_depth = depth.clone();
8080 if inlined {
8081 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8082 inner_offset = next_offset;
8083 } else {
8084 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8085 inner_depth.increment()?;
8086 }
8087 let val_ref =
8088 self.min_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8089 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8090 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8091 {
8092 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8093 }
8094 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8095 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8096 }
8097 }
8098
8099 next_offset += envelope_size;
8100 _next_ordinal_to_read += 1;
8101 if next_offset >= end_offset {
8102 return Ok(());
8103 }
8104
8105 while _next_ordinal_to_read < 2 {
8107 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8108 _next_ordinal_to_read += 1;
8109 next_offset += envelope_size;
8110 }
8111
8112 let next_out_of_line = decoder.next_out_of_line();
8113 let handles_before = decoder.remaining_handles();
8114 if let Some((inlined, num_bytes, num_handles)) =
8115 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8116 {
8117 let member_inline_size =
8118 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8119 if inlined != (member_inline_size <= 4) {
8120 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8121 }
8122 let inner_offset;
8123 let mut inner_depth = depth.clone();
8124 if inlined {
8125 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8126 inner_offset = next_offset;
8127 } else {
8128 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8129 inner_depth.increment()?;
8130 }
8131 let val_ref =
8132 self.max_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8133 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8135 {
8136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8137 }
8138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8140 }
8141 }
8142
8143 next_offset += envelope_size;
8144
8145 while next_offset < end_offset {
8147 _next_ordinal_to_read += 1;
8148 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8149 next_offset += envelope_size;
8150 }
8151
8152 Ok(())
8153 }
8154 }
8155
8156 impl ConnectedIsochronousGroupEstablishStreamsRequest {
8157 #[inline(always)]
8158 fn max_ordinal_present(&self) -> u64 {
8159 if let Some(_) = self.cis_params {
8160 return 1;
8161 }
8162 0
8163 }
8164 }
8165
8166 impl fidl::encoding::ValueTypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8167 type Borrowed<'a> = &'a Self;
8168 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8169 value
8170 }
8171 }
8172
8173 unsafe impl fidl::encoding::TypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8174 type Owned = Self;
8175
8176 #[inline(always)]
8177 fn inline_align(_context: fidl::encoding::Context) -> usize {
8178 8
8179 }
8180
8181 #[inline(always)]
8182 fn inline_size(_context: fidl::encoding::Context) -> usize {
8183 16
8184 }
8185 }
8186
8187 unsafe impl<D: fidl::encoding::ResourceDialect>
8188 fidl::encoding::Encode<ConnectedIsochronousGroupEstablishStreamsRequest, D>
8189 for &ConnectedIsochronousGroupEstablishStreamsRequest
8190 {
8191 unsafe fn encode(
8192 self,
8193 encoder: &mut fidl::encoding::Encoder<'_, D>,
8194 offset: usize,
8195 mut depth: fidl::encoding::Depth,
8196 ) -> fidl::Result<()> {
8197 encoder.debug_check_bounds::<ConnectedIsochronousGroupEstablishStreamsRequest>(offset);
8198 let max_ordinal: u64 = self.max_ordinal_present();
8200 encoder.write_num(max_ordinal, offset);
8201 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8202 if max_ordinal == 0 {
8204 return Ok(());
8205 }
8206 depth.increment()?;
8207 let envelope_size = 8;
8208 let bytes_len = max_ordinal as usize * envelope_size;
8209 #[allow(unused_variables)]
8210 let offset = encoder.out_of_line_offset(bytes_len);
8211 let mut _prev_end_offset: usize = 0;
8212 if 1 > max_ordinal {
8213 return Ok(());
8214 }
8215
8216 let cur_offset: usize = (1 - 1) * envelope_size;
8219
8220 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8222
8223 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CisParameters, 31>, D>(
8228 self.cis_params.as_ref().map(<fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::ValueTypeMarker>::borrow),
8229 encoder, offset + cur_offset, depth
8230 )?;
8231
8232 _prev_end_offset = cur_offset + envelope_size;
8233
8234 Ok(())
8235 }
8236 }
8237
8238 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8239 for ConnectedIsochronousGroupEstablishStreamsRequest
8240 {
8241 #[inline(always)]
8242 fn new_empty() -> Self {
8243 Self::default()
8244 }
8245
8246 unsafe fn decode(
8247 &mut self,
8248 decoder: &mut fidl::encoding::Decoder<'_, D>,
8249 offset: usize,
8250 mut depth: fidl::encoding::Depth,
8251 ) -> fidl::Result<()> {
8252 decoder.debug_check_bounds::<Self>(offset);
8253 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8254 None => return Err(fidl::Error::NotNullable),
8255 Some(len) => len,
8256 };
8257 if len == 0 {
8259 return Ok(());
8260 };
8261 depth.increment()?;
8262 let envelope_size = 8;
8263 let bytes_len = len * envelope_size;
8264 let offset = decoder.out_of_line_offset(bytes_len)?;
8265 let mut _next_ordinal_to_read = 0;
8267 let mut next_offset = offset;
8268 let end_offset = offset + bytes_len;
8269 _next_ordinal_to_read += 1;
8270 if next_offset >= end_offset {
8271 return Ok(());
8272 }
8273
8274 while _next_ordinal_to_read < 1 {
8276 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8277 _next_ordinal_to_read += 1;
8278 next_offset += envelope_size;
8279 }
8280
8281 let next_out_of_line = decoder.next_out_of_line();
8282 let handles_before = decoder.remaining_handles();
8283 if let Some((inlined, num_bytes, num_handles)) =
8284 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8285 {
8286 let member_inline_size = <fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8287 if inlined != (member_inline_size <= 4) {
8288 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8289 }
8290 let inner_offset;
8291 let mut inner_depth = depth.clone();
8292 if inlined {
8293 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8294 inner_offset = next_offset;
8295 } else {
8296 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8297 inner_depth.increment()?;
8298 }
8299 let val_ref = self.cis_params.get_or_insert_with(
8300 || fidl::new_empty!(fidl::encoding::Vector<CisParameters, 31>, D),
8301 );
8302 fidl::decode!(fidl::encoding::Vector<CisParameters, 31>, D, val_ref, decoder, inner_offset, inner_depth)?;
8303 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8304 {
8305 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8306 }
8307 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8308 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8309 }
8310 }
8311
8312 next_offset += envelope_size;
8313
8314 while next_offset < end_offset {
8316 _next_ordinal_to_read += 1;
8317 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8318 next_offset += envelope_size;
8319 }
8320
8321 Ok(())
8322 }
8323 }
8324
8325 impl ConnectionOptions {
8326 #[inline(always)]
8327 fn max_ordinal_present(&self) -> u64 {
8328 if let Some(_) = self.service_filter {
8329 return 2;
8330 }
8331 if let Some(_) = self.bondable_mode {
8332 return 1;
8333 }
8334 0
8335 }
8336 }
8337
8338 impl fidl::encoding::ValueTypeMarker for ConnectionOptions {
8339 type Borrowed<'a> = &'a Self;
8340 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8341 value
8342 }
8343 }
8344
8345 unsafe impl fidl::encoding::TypeMarker for ConnectionOptions {
8346 type Owned = Self;
8347
8348 #[inline(always)]
8349 fn inline_align(_context: fidl::encoding::Context) -> usize {
8350 8
8351 }
8352
8353 #[inline(always)]
8354 fn inline_size(_context: fidl::encoding::Context) -> usize {
8355 16
8356 }
8357 }
8358
8359 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionOptions, D>
8360 for &ConnectionOptions
8361 {
8362 unsafe fn encode(
8363 self,
8364 encoder: &mut fidl::encoding::Encoder<'_, D>,
8365 offset: usize,
8366 mut depth: fidl::encoding::Depth,
8367 ) -> fidl::Result<()> {
8368 encoder.debug_check_bounds::<ConnectionOptions>(offset);
8369 let max_ordinal: u64 = self.max_ordinal_present();
8371 encoder.write_num(max_ordinal, offset);
8372 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8373 if max_ordinal == 0 {
8375 return Ok(());
8376 }
8377 depth.increment()?;
8378 let envelope_size = 8;
8379 let bytes_len = max_ordinal as usize * envelope_size;
8380 #[allow(unused_variables)]
8381 let offset = encoder.out_of_line_offset(bytes_len);
8382 let mut _prev_end_offset: usize = 0;
8383 if 1 > max_ordinal {
8384 return Ok(());
8385 }
8386
8387 let cur_offset: usize = (1 - 1) * envelope_size;
8390
8391 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8393
8394 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8399 self.bondable_mode.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8400 encoder,
8401 offset + cur_offset,
8402 depth,
8403 )?;
8404
8405 _prev_end_offset = cur_offset + envelope_size;
8406 if 2 > max_ordinal {
8407 return Ok(());
8408 }
8409
8410 let cur_offset: usize = (2 - 1) * envelope_size;
8413
8414 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8416
8417 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8422 self.service_filter.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8423 encoder, offset + cur_offset, depth
8424 )?;
8425
8426 _prev_end_offset = cur_offset + envelope_size;
8427
8428 Ok(())
8429 }
8430 }
8431
8432 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionOptions {
8433 #[inline(always)]
8434 fn new_empty() -> Self {
8435 Self::default()
8436 }
8437
8438 unsafe fn decode(
8439 &mut self,
8440 decoder: &mut fidl::encoding::Decoder<'_, D>,
8441 offset: usize,
8442 mut depth: fidl::encoding::Depth,
8443 ) -> fidl::Result<()> {
8444 decoder.debug_check_bounds::<Self>(offset);
8445 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8446 None => return Err(fidl::Error::NotNullable),
8447 Some(len) => len,
8448 };
8449 if len == 0 {
8451 return Ok(());
8452 };
8453 depth.increment()?;
8454 let envelope_size = 8;
8455 let bytes_len = len * envelope_size;
8456 let offset = decoder.out_of_line_offset(bytes_len)?;
8457 let mut _next_ordinal_to_read = 0;
8459 let mut next_offset = offset;
8460 let end_offset = offset + bytes_len;
8461 _next_ordinal_to_read += 1;
8462 if next_offset >= end_offset {
8463 return Ok(());
8464 }
8465
8466 while _next_ordinal_to_read < 1 {
8468 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8469 _next_ordinal_to_read += 1;
8470 next_offset += envelope_size;
8471 }
8472
8473 let next_out_of_line = decoder.next_out_of_line();
8474 let handles_before = decoder.remaining_handles();
8475 if let Some((inlined, num_bytes, num_handles)) =
8476 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8477 {
8478 let member_inline_size =
8479 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8480 if inlined != (member_inline_size <= 4) {
8481 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8482 }
8483 let inner_offset;
8484 let mut inner_depth = depth.clone();
8485 if inlined {
8486 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8487 inner_offset = next_offset;
8488 } else {
8489 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8490 inner_depth.increment()?;
8491 }
8492 let val_ref = self.bondable_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
8493 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8494 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8495 {
8496 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8497 }
8498 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8499 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8500 }
8501 }
8502
8503 next_offset += envelope_size;
8504 _next_ordinal_to_read += 1;
8505 if next_offset >= end_offset {
8506 return Ok(());
8507 }
8508
8509 while _next_ordinal_to_read < 2 {
8511 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8512 _next_ordinal_to_read += 1;
8513 next_offset += envelope_size;
8514 }
8515
8516 let next_out_of_line = decoder.next_out_of_line();
8517 let handles_before = decoder.remaining_handles();
8518 if let Some((inlined, num_bytes, num_handles)) =
8519 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8520 {
8521 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8522 if inlined != (member_inline_size <= 4) {
8523 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8524 }
8525 let inner_offset;
8526 let mut inner_depth = depth.clone();
8527 if inlined {
8528 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8529 inner_offset = next_offset;
8530 } else {
8531 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8532 inner_depth.increment()?;
8533 }
8534 let val_ref = self.service_filter.get_or_insert_with(|| {
8535 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8536 });
8537 fidl::decode!(
8538 fidl_fuchsia_bluetooth__common::Uuid,
8539 D,
8540 val_ref,
8541 decoder,
8542 inner_offset,
8543 inner_depth
8544 )?;
8545 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8546 {
8547 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8548 }
8549 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8550 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8551 }
8552 }
8553
8554 next_offset += envelope_size;
8555
8556 while next_offset < end_offset {
8558 _next_ordinal_to_read += 1;
8559 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8560 next_offset += envelope_size;
8561 }
8562
8563 Ok(())
8564 }
8565 }
8566
8567 impl Extended {
8568 #[inline(always)]
8569 fn max_ordinal_present(&self) -> u64 {
8570 0
8571 }
8572 }
8573
8574 impl fidl::encoding::ValueTypeMarker for Extended {
8575 type Borrowed<'a> = &'a Self;
8576 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8577 value
8578 }
8579 }
8580
8581 unsafe impl fidl::encoding::TypeMarker for Extended {
8582 type Owned = Self;
8583
8584 #[inline(always)]
8585 fn inline_align(_context: fidl::encoding::Context) -> usize {
8586 8
8587 }
8588
8589 #[inline(always)]
8590 fn inline_size(_context: fidl::encoding::Context) -> usize {
8591 16
8592 }
8593 }
8594
8595 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Extended, D> for &Extended {
8596 unsafe fn encode(
8597 self,
8598 encoder: &mut fidl::encoding::Encoder<'_, D>,
8599 offset: usize,
8600 mut depth: fidl::encoding::Depth,
8601 ) -> fidl::Result<()> {
8602 encoder.debug_check_bounds::<Extended>(offset);
8603 let max_ordinal: u64 = self.max_ordinal_present();
8605 encoder.write_num(max_ordinal, offset);
8606 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8607 if max_ordinal == 0 {
8609 return Ok(());
8610 }
8611 depth.increment()?;
8612 let envelope_size = 8;
8613 let bytes_len = max_ordinal as usize * envelope_size;
8614 #[allow(unused_variables)]
8615 let offset = encoder.out_of_line_offset(bytes_len);
8616 let mut _prev_end_offset: usize = 0;
8617
8618 Ok(())
8619 }
8620 }
8621
8622 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Extended {
8623 #[inline(always)]
8624 fn new_empty() -> Self {
8625 Self::default()
8626 }
8627
8628 unsafe fn decode(
8629 &mut self,
8630 decoder: &mut fidl::encoding::Decoder<'_, D>,
8631 offset: usize,
8632 mut depth: fidl::encoding::Depth,
8633 ) -> fidl::Result<()> {
8634 decoder.debug_check_bounds::<Self>(offset);
8635 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8636 None => return Err(fidl::Error::NotNullable),
8637 Some(len) => len,
8638 };
8639 if len == 0 {
8641 return Ok(());
8642 };
8643 depth.increment()?;
8644 let envelope_size = 8;
8645 let bytes_len = len * envelope_size;
8646 let offset = decoder.out_of_line_offset(bytes_len)?;
8647 let mut _next_ordinal_to_read = 0;
8649 let mut next_offset = offset;
8650 let end_offset = offset + bytes_len;
8651
8652 while next_offset < end_offset {
8654 _next_ordinal_to_read += 1;
8655 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8656 next_offset += envelope_size;
8657 }
8658
8659 Ok(())
8660 }
8661 }
8662
8663 impl Filter {
8664 #[inline(always)]
8665 fn max_ordinal_present(&self) -> u64 {
8666 if let Some(_) = self.solicitation_uuid {
8667 return 7;
8668 }
8669 if let Some(_) = self.max_path_loss {
8670 return 6;
8671 }
8672 if let Some(_) = self.name {
8673 return 5;
8674 }
8675 if let Some(_) = self.connectable {
8676 return 4;
8677 }
8678 if let Some(_) = self.manufacturer_id {
8679 return 3;
8680 }
8681 if let Some(_) = self.service_data_uuid {
8682 return 2;
8683 }
8684 if let Some(_) = self.service_uuid {
8685 return 1;
8686 }
8687 0
8688 }
8689 }
8690
8691 impl fidl::encoding::ValueTypeMarker for Filter {
8692 type Borrowed<'a> = &'a Self;
8693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8694 value
8695 }
8696 }
8697
8698 unsafe impl fidl::encoding::TypeMarker for Filter {
8699 type Owned = Self;
8700
8701 #[inline(always)]
8702 fn inline_align(_context: fidl::encoding::Context) -> usize {
8703 8
8704 }
8705
8706 #[inline(always)]
8707 fn inline_size(_context: fidl::encoding::Context) -> usize {
8708 16
8709 }
8710 }
8711
8712 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Filter, D> for &Filter {
8713 unsafe fn encode(
8714 self,
8715 encoder: &mut fidl::encoding::Encoder<'_, D>,
8716 offset: usize,
8717 mut depth: fidl::encoding::Depth,
8718 ) -> fidl::Result<()> {
8719 encoder.debug_check_bounds::<Filter>(offset);
8720 let max_ordinal: u64 = self.max_ordinal_present();
8722 encoder.write_num(max_ordinal, offset);
8723 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8724 if max_ordinal == 0 {
8726 return Ok(());
8727 }
8728 depth.increment()?;
8729 let envelope_size = 8;
8730 let bytes_len = max_ordinal as usize * envelope_size;
8731 #[allow(unused_variables)]
8732 let offset = encoder.out_of_line_offset(bytes_len);
8733 let mut _prev_end_offset: usize = 0;
8734 if 1 > max_ordinal {
8735 return Ok(());
8736 }
8737
8738 let cur_offset: usize = (1 - 1) * envelope_size;
8741
8742 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8744
8745 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8750 self.service_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8751 encoder, offset + cur_offset, depth
8752 )?;
8753
8754 _prev_end_offset = cur_offset + envelope_size;
8755 if 2 > max_ordinal {
8756 return Ok(());
8757 }
8758
8759 let cur_offset: usize = (2 - 1) * envelope_size;
8762
8763 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8765
8766 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8771 self.service_data_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8772 encoder, offset + cur_offset, depth
8773 )?;
8774
8775 _prev_end_offset = cur_offset + envelope_size;
8776 if 3 > max_ordinal {
8777 return Ok(());
8778 }
8779
8780 let cur_offset: usize = (3 - 1) * envelope_size;
8783
8784 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8786
8787 fidl::encoding::encode_in_envelope_optional::<u16, D>(
8792 self.manufacturer_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
8793 encoder,
8794 offset + cur_offset,
8795 depth,
8796 )?;
8797
8798 _prev_end_offset = cur_offset + envelope_size;
8799 if 4 > max_ordinal {
8800 return Ok(());
8801 }
8802
8803 let cur_offset: usize = (4 - 1) * envelope_size;
8806
8807 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8809
8810 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8815 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8816 encoder,
8817 offset + cur_offset,
8818 depth,
8819 )?;
8820
8821 _prev_end_offset = cur_offset + envelope_size;
8822 if 5 > max_ordinal {
8823 return Ok(());
8824 }
8825
8826 let cur_offset: usize = (5 - 1) * envelope_size;
8829
8830 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8832
8833 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
8838 self.name.as_ref().map(
8839 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
8840 ),
8841 encoder,
8842 offset + cur_offset,
8843 depth,
8844 )?;
8845
8846 _prev_end_offset = cur_offset + envelope_size;
8847 if 6 > max_ordinal {
8848 return Ok(());
8849 }
8850
8851 let cur_offset: usize = (6 - 1) * envelope_size;
8854
8855 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8857
8858 fidl::encoding::encode_in_envelope_optional::<i8, D>(
8863 self.max_path_loss.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
8864 encoder,
8865 offset + cur_offset,
8866 depth,
8867 )?;
8868
8869 _prev_end_offset = cur_offset + envelope_size;
8870 if 7 > max_ordinal {
8871 return Ok(());
8872 }
8873
8874 let cur_offset: usize = (7 - 1) * envelope_size;
8877
8878 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8880
8881 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8886 self.solicitation_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8887 encoder, offset + cur_offset, depth
8888 )?;
8889
8890 _prev_end_offset = cur_offset + envelope_size;
8891
8892 Ok(())
8893 }
8894 }
8895
8896 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Filter {
8897 #[inline(always)]
8898 fn new_empty() -> Self {
8899 Self::default()
8900 }
8901
8902 unsafe fn decode(
8903 &mut self,
8904 decoder: &mut fidl::encoding::Decoder<'_, D>,
8905 offset: usize,
8906 mut depth: fidl::encoding::Depth,
8907 ) -> fidl::Result<()> {
8908 decoder.debug_check_bounds::<Self>(offset);
8909 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8910 None => return Err(fidl::Error::NotNullable),
8911 Some(len) => len,
8912 };
8913 if len == 0 {
8915 return Ok(());
8916 };
8917 depth.increment()?;
8918 let envelope_size = 8;
8919 let bytes_len = len * envelope_size;
8920 let offset = decoder.out_of_line_offset(bytes_len)?;
8921 let mut _next_ordinal_to_read = 0;
8923 let mut next_offset = offset;
8924 let end_offset = offset + bytes_len;
8925 _next_ordinal_to_read += 1;
8926 if next_offset >= end_offset {
8927 return Ok(());
8928 }
8929
8930 while _next_ordinal_to_read < 1 {
8932 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8933 _next_ordinal_to_read += 1;
8934 next_offset += envelope_size;
8935 }
8936
8937 let next_out_of_line = decoder.next_out_of_line();
8938 let handles_before = decoder.remaining_handles();
8939 if let Some((inlined, num_bytes, num_handles)) =
8940 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8941 {
8942 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8943 if inlined != (member_inline_size <= 4) {
8944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8945 }
8946 let inner_offset;
8947 let mut inner_depth = depth.clone();
8948 if inlined {
8949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8950 inner_offset = next_offset;
8951 } else {
8952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8953 inner_depth.increment()?;
8954 }
8955 let val_ref = self.service_uuid.get_or_insert_with(|| {
8956 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8957 });
8958 fidl::decode!(
8959 fidl_fuchsia_bluetooth__common::Uuid,
8960 D,
8961 val_ref,
8962 decoder,
8963 inner_offset,
8964 inner_depth
8965 )?;
8966 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8967 {
8968 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8969 }
8970 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8971 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8972 }
8973 }
8974
8975 next_offset += envelope_size;
8976 _next_ordinal_to_read += 1;
8977 if next_offset >= end_offset {
8978 return Ok(());
8979 }
8980
8981 while _next_ordinal_to_read < 2 {
8983 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8984 _next_ordinal_to_read += 1;
8985 next_offset += envelope_size;
8986 }
8987
8988 let next_out_of_line = decoder.next_out_of_line();
8989 let handles_before = decoder.remaining_handles();
8990 if let Some((inlined, num_bytes, num_handles)) =
8991 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8992 {
8993 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8994 if inlined != (member_inline_size <= 4) {
8995 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8996 }
8997 let inner_offset;
8998 let mut inner_depth = depth.clone();
8999 if inlined {
9000 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9001 inner_offset = next_offset;
9002 } else {
9003 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9004 inner_depth.increment()?;
9005 }
9006 let val_ref = self.service_data_uuid.get_or_insert_with(|| {
9007 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9008 });
9009 fidl::decode!(
9010 fidl_fuchsia_bluetooth__common::Uuid,
9011 D,
9012 val_ref,
9013 decoder,
9014 inner_offset,
9015 inner_depth
9016 )?;
9017 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9018 {
9019 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9020 }
9021 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9022 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9023 }
9024 }
9025
9026 next_offset += envelope_size;
9027 _next_ordinal_to_read += 1;
9028 if next_offset >= end_offset {
9029 return Ok(());
9030 }
9031
9032 while _next_ordinal_to_read < 3 {
9034 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9035 _next_ordinal_to_read += 1;
9036 next_offset += envelope_size;
9037 }
9038
9039 let next_out_of_line = decoder.next_out_of_line();
9040 let handles_before = decoder.remaining_handles();
9041 if let Some((inlined, num_bytes, num_handles)) =
9042 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9043 {
9044 let member_inline_size =
9045 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9046 if inlined != (member_inline_size <= 4) {
9047 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9048 }
9049 let inner_offset;
9050 let mut inner_depth = depth.clone();
9051 if inlined {
9052 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9053 inner_offset = next_offset;
9054 } else {
9055 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9056 inner_depth.increment()?;
9057 }
9058 let val_ref = self.manufacturer_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9059 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9060 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9061 {
9062 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9063 }
9064 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9065 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9066 }
9067 }
9068
9069 next_offset += envelope_size;
9070 _next_ordinal_to_read += 1;
9071 if next_offset >= end_offset {
9072 return Ok(());
9073 }
9074
9075 while _next_ordinal_to_read < 4 {
9077 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9078 _next_ordinal_to_read += 1;
9079 next_offset += envelope_size;
9080 }
9081
9082 let next_out_of_line = decoder.next_out_of_line();
9083 let handles_before = decoder.remaining_handles();
9084 if let Some((inlined, num_bytes, num_handles)) =
9085 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9086 {
9087 let member_inline_size =
9088 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9089 if inlined != (member_inline_size <= 4) {
9090 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9091 }
9092 let inner_offset;
9093 let mut inner_depth = depth.clone();
9094 if inlined {
9095 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9096 inner_offset = next_offset;
9097 } else {
9098 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9099 inner_depth.increment()?;
9100 }
9101 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
9102 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9103 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9104 {
9105 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9106 }
9107 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9108 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9109 }
9110 }
9111
9112 next_offset += envelope_size;
9113 _next_ordinal_to_read += 1;
9114 if next_offset >= end_offset {
9115 return Ok(());
9116 }
9117
9118 while _next_ordinal_to_read < 5 {
9120 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9121 _next_ordinal_to_read += 1;
9122 next_offset += envelope_size;
9123 }
9124
9125 let next_out_of_line = decoder.next_out_of_line();
9126 let handles_before = decoder.remaining_handles();
9127 if let Some((inlined, num_bytes, num_handles)) =
9128 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9129 {
9130 let member_inline_size =
9131 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
9132 decoder.context,
9133 );
9134 if inlined != (member_inline_size <= 4) {
9135 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9136 }
9137 let inner_offset;
9138 let mut inner_depth = depth.clone();
9139 if inlined {
9140 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9141 inner_offset = next_offset;
9142 } else {
9143 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9144 inner_depth.increment()?;
9145 }
9146 let val_ref = self
9147 .name
9148 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
9149 fidl::decode!(
9150 fidl::encoding::BoundedString<248>,
9151 D,
9152 val_ref,
9153 decoder,
9154 inner_offset,
9155 inner_depth
9156 )?;
9157 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9158 {
9159 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9160 }
9161 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9162 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9163 }
9164 }
9165
9166 next_offset += envelope_size;
9167 _next_ordinal_to_read += 1;
9168 if next_offset >= end_offset {
9169 return Ok(());
9170 }
9171
9172 while _next_ordinal_to_read < 6 {
9174 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9175 _next_ordinal_to_read += 1;
9176 next_offset += envelope_size;
9177 }
9178
9179 let next_out_of_line = decoder.next_out_of_line();
9180 let handles_before = decoder.remaining_handles();
9181 if let Some((inlined, num_bytes, num_handles)) =
9182 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9183 {
9184 let member_inline_size =
9185 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9186 if inlined != (member_inline_size <= 4) {
9187 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9188 }
9189 let inner_offset;
9190 let mut inner_depth = depth.clone();
9191 if inlined {
9192 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9193 inner_offset = next_offset;
9194 } else {
9195 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9196 inner_depth.increment()?;
9197 }
9198 let val_ref = self.max_path_loss.get_or_insert_with(|| fidl::new_empty!(i8, D));
9199 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
9200 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9201 {
9202 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9203 }
9204 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9205 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9206 }
9207 }
9208
9209 next_offset += envelope_size;
9210 _next_ordinal_to_read += 1;
9211 if next_offset >= end_offset {
9212 return Ok(());
9213 }
9214
9215 while _next_ordinal_to_read < 7 {
9217 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9218 _next_ordinal_to_read += 1;
9219 next_offset += envelope_size;
9220 }
9221
9222 let next_out_of_line = decoder.next_out_of_line();
9223 let handles_before = decoder.remaining_handles();
9224 if let Some((inlined, num_bytes, num_handles)) =
9225 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9226 {
9227 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9228 if inlined != (member_inline_size <= 4) {
9229 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9230 }
9231 let inner_offset;
9232 let mut inner_depth = depth.clone();
9233 if inlined {
9234 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9235 inner_offset = next_offset;
9236 } else {
9237 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9238 inner_depth.increment()?;
9239 }
9240 let val_ref = self.solicitation_uuid.get_or_insert_with(|| {
9241 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9242 });
9243 fidl::decode!(
9244 fidl_fuchsia_bluetooth__common::Uuid,
9245 D,
9246 val_ref,
9247 decoder,
9248 inner_offset,
9249 inner_depth
9250 )?;
9251 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9252 {
9253 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9254 }
9255 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9256 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9257 }
9258 }
9259
9260 next_offset += envelope_size;
9261
9262 while next_offset < end_offset {
9264 _next_ordinal_to_read += 1;
9265 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9266 next_offset += envelope_size;
9267 }
9268
9269 Ok(())
9270 }
9271 }
9272
9273 impl IsochronousStreamOnEstablishedRequest {
9274 #[inline(always)]
9275 fn max_ordinal_present(&self) -> u64 {
9276 if let Some(_) = self.established_params {
9277 return 2;
9278 }
9279 if let Some(_) = self.result {
9280 return 1;
9281 }
9282 0
9283 }
9284 }
9285
9286 impl fidl::encoding::ValueTypeMarker for IsochronousStreamOnEstablishedRequest {
9287 type Borrowed<'a> = &'a Self;
9288 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9289 value
9290 }
9291 }
9292
9293 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamOnEstablishedRequest {
9294 type Owned = Self;
9295
9296 #[inline(always)]
9297 fn inline_align(_context: fidl::encoding::Context) -> usize {
9298 8
9299 }
9300
9301 #[inline(always)]
9302 fn inline_size(_context: fidl::encoding::Context) -> usize {
9303 16
9304 }
9305 }
9306
9307 unsafe impl<D: fidl::encoding::ResourceDialect>
9308 fidl::encoding::Encode<IsochronousStreamOnEstablishedRequest, D>
9309 for &IsochronousStreamOnEstablishedRequest
9310 {
9311 unsafe fn encode(
9312 self,
9313 encoder: &mut fidl::encoding::Encoder<'_, D>,
9314 offset: usize,
9315 mut depth: fidl::encoding::Depth,
9316 ) -> fidl::Result<()> {
9317 encoder.debug_check_bounds::<IsochronousStreamOnEstablishedRequest>(offset);
9318 let max_ordinal: u64 = self.max_ordinal_present();
9320 encoder.write_num(max_ordinal, offset);
9321 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9322 if max_ordinal == 0 {
9324 return Ok(());
9325 }
9326 depth.increment()?;
9327 let envelope_size = 8;
9328 let bytes_len = max_ordinal as usize * envelope_size;
9329 #[allow(unused_variables)]
9330 let offset = encoder.out_of_line_offset(bytes_len);
9331 let mut _prev_end_offset: usize = 0;
9332 if 1 > max_ordinal {
9333 return Ok(());
9334 }
9335
9336 let cur_offset: usize = (1 - 1) * envelope_size;
9339
9340 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9342
9343 fidl::encoding::encode_in_envelope_optional::<i32, D>(
9348 self.result.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
9349 encoder,
9350 offset + cur_offset,
9351 depth,
9352 )?;
9353
9354 _prev_end_offset = cur_offset + envelope_size;
9355 if 2 > max_ordinal {
9356 return Ok(());
9357 }
9358
9359 let cur_offset: usize = (2 - 1) * envelope_size;
9362
9363 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9365
9366 fidl::encoding::encode_in_envelope_optional::<CisEstablishedParameters, D>(
9371 self.established_params
9372 .as_ref()
9373 .map(<CisEstablishedParameters as fidl::encoding::ValueTypeMarker>::borrow),
9374 encoder,
9375 offset + cur_offset,
9376 depth,
9377 )?;
9378
9379 _prev_end_offset = cur_offset + envelope_size;
9380
9381 Ok(())
9382 }
9383 }
9384
9385 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9386 for IsochronousStreamOnEstablishedRequest
9387 {
9388 #[inline(always)]
9389 fn new_empty() -> Self {
9390 Self::default()
9391 }
9392
9393 unsafe fn decode(
9394 &mut self,
9395 decoder: &mut fidl::encoding::Decoder<'_, D>,
9396 offset: usize,
9397 mut depth: fidl::encoding::Depth,
9398 ) -> fidl::Result<()> {
9399 decoder.debug_check_bounds::<Self>(offset);
9400 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9401 None => return Err(fidl::Error::NotNullable),
9402 Some(len) => len,
9403 };
9404 if len == 0 {
9406 return Ok(());
9407 };
9408 depth.increment()?;
9409 let envelope_size = 8;
9410 let bytes_len = len * envelope_size;
9411 let offset = decoder.out_of_line_offset(bytes_len)?;
9412 let mut _next_ordinal_to_read = 0;
9414 let mut next_offset = offset;
9415 let end_offset = offset + bytes_len;
9416 _next_ordinal_to_read += 1;
9417 if next_offset >= end_offset {
9418 return Ok(());
9419 }
9420
9421 while _next_ordinal_to_read < 1 {
9423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9424 _next_ordinal_to_read += 1;
9425 next_offset += envelope_size;
9426 }
9427
9428 let next_out_of_line = decoder.next_out_of_line();
9429 let handles_before = decoder.remaining_handles();
9430 if let Some((inlined, num_bytes, num_handles)) =
9431 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9432 {
9433 let member_inline_size =
9434 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9435 if inlined != (member_inline_size <= 4) {
9436 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9437 }
9438 let inner_offset;
9439 let mut inner_depth = depth.clone();
9440 if inlined {
9441 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9442 inner_offset = next_offset;
9443 } else {
9444 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9445 inner_depth.increment()?;
9446 }
9447 let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(i32, D));
9448 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
9449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9450 {
9451 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9452 }
9453 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9454 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9455 }
9456 }
9457
9458 next_offset += envelope_size;
9459 _next_ordinal_to_read += 1;
9460 if next_offset >= end_offset {
9461 return Ok(());
9462 }
9463
9464 while _next_ordinal_to_read < 2 {
9466 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9467 _next_ordinal_to_read += 1;
9468 next_offset += envelope_size;
9469 }
9470
9471 let next_out_of_line = decoder.next_out_of_line();
9472 let handles_before = decoder.remaining_handles();
9473 if let Some((inlined, num_bytes, num_handles)) =
9474 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9475 {
9476 let member_inline_size =
9477 <CisEstablishedParameters as fidl::encoding::TypeMarker>::inline_size(
9478 decoder.context,
9479 );
9480 if inlined != (member_inline_size <= 4) {
9481 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9482 }
9483 let inner_offset;
9484 let mut inner_depth = depth.clone();
9485 if inlined {
9486 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9487 inner_offset = next_offset;
9488 } else {
9489 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9490 inner_depth.increment()?;
9491 }
9492 let val_ref = self
9493 .established_params
9494 .get_or_insert_with(|| fidl::new_empty!(CisEstablishedParameters, D));
9495 fidl::decode!(
9496 CisEstablishedParameters,
9497 D,
9498 val_ref,
9499 decoder,
9500 inner_offset,
9501 inner_depth
9502 )?;
9503 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9504 {
9505 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9506 }
9507 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9508 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9509 }
9510 }
9511
9512 next_offset += envelope_size;
9513
9514 while next_offset < end_offset {
9516 _next_ordinal_to_read += 1;
9517 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9518 next_offset += envelope_size;
9519 }
9520
9521 Ok(())
9522 }
9523 }
9524
9525 impl IsochronousStreamSetupDataPathRequest {
9526 #[inline(always)]
9527 fn max_ordinal_present(&self) -> u64 {
9528 if let Some(_) = self.controller_delay {
9529 return 3;
9530 }
9531 if let Some(_) = self.codec_attributes {
9532 return 2;
9533 }
9534 if let Some(_) = self.data_direction {
9535 return 1;
9536 }
9537 0
9538 }
9539 }
9540
9541 impl fidl::encoding::ValueTypeMarker for IsochronousStreamSetupDataPathRequest {
9542 type Borrowed<'a> = &'a Self;
9543 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9544 value
9545 }
9546 }
9547
9548 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamSetupDataPathRequest {
9549 type Owned = Self;
9550
9551 #[inline(always)]
9552 fn inline_align(_context: fidl::encoding::Context) -> usize {
9553 8
9554 }
9555
9556 #[inline(always)]
9557 fn inline_size(_context: fidl::encoding::Context) -> usize {
9558 16
9559 }
9560 }
9561
9562 unsafe impl<D: fidl::encoding::ResourceDialect>
9563 fidl::encoding::Encode<IsochronousStreamSetupDataPathRequest, D>
9564 for &IsochronousStreamSetupDataPathRequest
9565 {
9566 unsafe fn encode(
9567 self,
9568 encoder: &mut fidl::encoding::Encoder<'_, D>,
9569 offset: usize,
9570 mut depth: fidl::encoding::Depth,
9571 ) -> fidl::Result<()> {
9572 encoder.debug_check_bounds::<IsochronousStreamSetupDataPathRequest>(offset);
9573 let max_ordinal: u64 = self.max_ordinal_present();
9575 encoder.write_num(max_ordinal, offset);
9576 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9577 if max_ordinal == 0 {
9579 return Ok(());
9580 }
9581 depth.increment()?;
9582 let envelope_size = 8;
9583 let bytes_len = max_ordinal as usize * envelope_size;
9584 #[allow(unused_variables)]
9585 let offset = encoder.out_of_line_offset(bytes_len);
9586 let mut _prev_end_offset: usize = 0;
9587 if 1 > max_ordinal {
9588 return Ok(());
9589 }
9590
9591 let cur_offset: usize = (1 - 1) * envelope_size;
9594
9595 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9597
9598 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
9603 self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
9604 encoder, offset + cur_offset, depth
9605 )?;
9606
9607 _prev_end_offset = cur_offset + envelope_size;
9608 if 2 > max_ordinal {
9609 return Ok(());
9610 }
9611
9612 let cur_offset: usize = (2 - 1) * envelope_size;
9615
9616 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9618
9619 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
9624 self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
9625 encoder, offset + cur_offset, depth
9626 )?;
9627
9628 _prev_end_offset = cur_offset + envelope_size;
9629 if 3 > max_ordinal {
9630 return Ok(());
9631 }
9632
9633 let cur_offset: usize = (3 - 1) * envelope_size;
9636
9637 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9639
9640 fidl::encoding::encode_in_envelope_optional::<i64, D>(
9645 self.controller_delay
9646 .as_ref()
9647 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9648 encoder,
9649 offset + cur_offset,
9650 depth,
9651 )?;
9652
9653 _prev_end_offset = cur_offset + envelope_size;
9654
9655 Ok(())
9656 }
9657 }
9658
9659 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9660 for IsochronousStreamSetupDataPathRequest
9661 {
9662 #[inline(always)]
9663 fn new_empty() -> Self {
9664 Self::default()
9665 }
9666
9667 unsafe fn decode(
9668 &mut self,
9669 decoder: &mut fidl::encoding::Decoder<'_, D>,
9670 offset: usize,
9671 mut depth: fidl::encoding::Depth,
9672 ) -> fidl::Result<()> {
9673 decoder.debug_check_bounds::<Self>(offset);
9674 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9675 None => return Err(fidl::Error::NotNullable),
9676 Some(len) => len,
9677 };
9678 if len == 0 {
9680 return Ok(());
9681 };
9682 depth.increment()?;
9683 let envelope_size = 8;
9684 let bytes_len = len * envelope_size;
9685 let offset = decoder.out_of_line_offset(bytes_len)?;
9686 let mut _next_ordinal_to_read = 0;
9688 let mut next_offset = offset;
9689 let end_offset = offset + bytes_len;
9690 _next_ordinal_to_read += 1;
9691 if next_offset >= end_offset {
9692 return Ok(());
9693 }
9694
9695 while _next_ordinal_to_read < 1 {
9697 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9698 _next_ordinal_to_read += 1;
9699 next_offset += envelope_size;
9700 }
9701
9702 let next_out_of_line = decoder.next_out_of_line();
9703 let handles_before = decoder.remaining_handles();
9704 if let Some((inlined, num_bytes, num_handles)) =
9705 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9706 {
9707 let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9708 if inlined != (member_inline_size <= 4) {
9709 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9710 }
9711 let inner_offset;
9712 let mut inner_depth = depth.clone();
9713 if inlined {
9714 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9715 inner_offset = next_offset;
9716 } else {
9717 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9718 inner_depth.increment()?;
9719 }
9720 let val_ref = self.data_direction.get_or_insert_with(|| {
9721 fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
9722 });
9723 fidl::decode!(
9724 fidl_fuchsia_bluetooth__common::DataDirection,
9725 D,
9726 val_ref,
9727 decoder,
9728 inner_offset,
9729 inner_depth
9730 )?;
9731 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9732 {
9733 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9734 }
9735 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9736 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9737 }
9738 }
9739
9740 next_offset += envelope_size;
9741 _next_ordinal_to_read += 1;
9742 if next_offset >= end_offset {
9743 return Ok(());
9744 }
9745
9746 while _next_ordinal_to_read < 2 {
9748 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9749 _next_ordinal_to_read += 1;
9750 next_offset += envelope_size;
9751 }
9752
9753 let next_out_of_line = decoder.next_out_of_line();
9754 let handles_before = decoder.remaining_handles();
9755 if let Some((inlined, num_bytes, num_handles)) =
9756 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9757 {
9758 let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9759 if inlined != (member_inline_size <= 4) {
9760 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9761 }
9762 let inner_offset;
9763 let mut inner_depth = depth.clone();
9764 if inlined {
9765 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9766 inner_offset = next_offset;
9767 } else {
9768 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9769 inner_depth.increment()?;
9770 }
9771 let val_ref = self.codec_attributes.get_or_insert_with(|| {
9772 fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
9773 });
9774 fidl::decode!(
9775 fidl_fuchsia_bluetooth__common::CodecAttributes,
9776 D,
9777 val_ref,
9778 decoder,
9779 inner_offset,
9780 inner_depth
9781 )?;
9782 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9783 {
9784 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9785 }
9786 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9787 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9788 }
9789 }
9790
9791 next_offset += envelope_size;
9792 _next_ordinal_to_read += 1;
9793 if next_offset >= end_offset {
9794 return Ok(());
9795 }
9796
9797 while _next_ordinal_to_read < 3 {
9799 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9800 _next_ordinal_to_read += 1;
9801 next_offset += envelope_size;
9802 }
9803
9804 let next_out_of_line = decoder.next_out_of_line();
9805 let handles_before = decoder.remaining_handles();
9806 if let Some((inlined, num_bytes, num_handles)) =
9807 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9808 {
9809 let member_inline_size =
9810 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9811 if inlined != (member_inline_size <= 4) {
9812 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9813 }
9814 let inner_offset;
9815 let mut inner_depth = depth.clone();
9816 if inlined {
9817 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9818 inner_offset = next_offset;
9819 } else {
9820 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9821 inner_depth.increment()?;
9822 }
9823 let val_ref = self.controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
9824 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9825 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9826 {
9827 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9828 }
9829 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9830 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9831 }
9832 }
9833
9834 next_offset += envelope_size;
9835
9836 while next_offset < end_offset {
9838 _next_ordinal_to_read += 1;
9839 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9840 next_offset += envelope_size;
9841 }
9842
9843 Ok(())
9844 }
9845 }
9846
9847 impl IsochronousStreamWriteRequest {
9848 #[inline(always)]
9849 fn max_ordinal_present(&self) -> u64 {
9850 if let Some(_) = self.data {
9851 return 1;
9852 }
9853 0
9854 }
9855 }
9856
9857 impl fidl::encoding::ValueTypeMarker for IsochronousStreamWriteRequest {
9858 type Borrowed<'a> = &'a Self;
9859 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9860 value
9861 }
9862 }
9863
9864 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamWriteRequest {
9865 type Owned = Self;
9866
9867 #[inline(always)]
9868 fn inline_align(_context: fidl::encoding::Context) -> usize {
9869 8
9870 }
9871
9872 #[inline(always)]
9873 fn inline_size(_context: fidl::encoding::Context) -> usize {
9874 16
9875 }
9876 }
9877
9878 unsafe impl<D: fidl::encoding::ResourceDialect>
9879 fidl::encoding::Encode<IsochronousStreamWriteRequest, D>
9880 for &IsochronousStreamWriteRequest
9881 {
9882 unsafe fn encode(
9883 self,
9884 encoder: &mut fidl::encoding::Encoder<'_, D>,
9885 offset: usize,
9886 mut depth: fidl::encoding::Depth,
9887 ) -> fidl::Result<()> {
9888 encoder.debug_check_bounds::<IsochronousStreamWriteRequest>(offset);
9889 let max_ordinal: u64 = self.max_ordinal_present();
9891 encoder.write_num(max_ordinal, offset);
9892 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9893 if max_ordinal == 0 {
9895 return Ok(());
9896 }
9897 depth.increment()?;
9898 let envelope_size = 8;
9899 let bytes_len = max_ordinal as usize * envelope_size;
9900 #[allow(unused_variables)]
9901 let offset = encoder.out_of_line_offset(bytes_len);
9902 let mut _prev_end_offset: usize = 0;
9903 if 1 > max_ordinal {
9904 return Ok(());
9905 }
9906
9907 let cur_offset: usize = (1 - 1) * envelope_size;
9910
9911 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9913
9914 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4095>, D>(
9919 self.data.as_ref().map(
9920 <fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow,
9921 ),
9922 encoder,
9923 offset + cur_offset,
9924 depth,
9925 )?;
9926
9927 _prev_end_offset = cur_offset + envelope_size;
9928
9929 Ok(())
9930 }
9931 }
9932
9933 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9934 for IsochronousStreamWriteRequest
9935 {
9936 #[inline(always)]
9937 fn new_empty() -> Self {
9938 Self::default()
9939 }
9940
9941 unsafe fn decode(
9942 &mut self,
9943 decoder: &mut fidl::encoding::Decoder<'_, D>,
9944 offset: usize,
9945 mut depth: fidl::encoding::Depth,
9946 ) -> fidl::Result<()> {
9947 decoder.debug_check_bounds::<Self>(offset);
9948 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9949 None => return Err(fidl::Error::NotNullable),
9950 Some(len) => len,
9951 };
9952 if len == 0 {
9954 return Ok(());
9955 };
9956 depth.increment()?;
9957 let envelope_size = 8;
9958 let bytes_len = len * envelope_size;
9959 let offset = decoder.out_of_line_offset(bytes_len)?;
9960 let mut _next_ordinal_to_read = 0;
9962 let mut next_offset = offset;
9963 let end_offset = offset + bytes_len;
9964 _next_ordinal_to_read += 1;
9965 if next_offset >= end_offset {
9966 return Ok(());
9967 }
9968
9969 while _next_ordinal_to_read < 1 {
9971 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9972 _next_ordinal_to_read += 1;
9973 next_offset += envelope_size;
9974 }
9975
9976 let next_out_of_line = decoder.next_out_of_line();
9977 let handles_before = decoder.remaining_handles();
9978 if let Some((inlined, num_bytes, num_handles)) =
9979 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9980 {
9981 let member_inline_size =
9982 <fidl::encoding::Vector<u8, 4095> as fidl::encoding::TypeMarker>::inline_size(
9983 decoder.context,
9984 );
9985 if inlined != (member_inline_size <= 4) {
9986 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9987 }
9988 let inner_offset;
9989 let mut inner_depth = depth.clone();
9990 if inlined {
9991 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9992 inner_offset = next_offset;
9993 } else {
9994 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9995 inner_depth.increment()?;
9996 }
9997 let val_ref = self
9998 .data
9999 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D));
10000 fidl::decode!(fidl::encoding::Vector<u8, 4095>, D, val_ref, decoder, inner_offset, inner_depth)?;
10001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10002 {
10003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10004 }
10005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10007 }
10008 }
10009
10010 next_offset += envelope_size;
10011
10012 while next_offset < end_offset {
10014 _next_ordinal_to_read += 1;
10015 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10016 next_offset += envelope_size;
10017 }
10018
10019 Ok(())
10020 }
10021 }
10022
10023 impl IsochronousStreamReadResponse {
10024 #[inline(always)]
10025 fn max_ordinal_present(&self) -> u64 {
10026 if let Some(_) = self.timestamp {
10027 return 4;
10028 }
10029 if let Some(_) = self.status_flag {
10030 return 3;
10031 }
10032 if let Some(_) = self.sequence_number {
10033 return 2;
10034 }
10035 if let Some(_) = self.data {
10036 return 1;
10037 }
10038 0
10039 }
10040 }
10041
10042 impl fidl::encoding::ValueTypeMarker for IsochronousStreamReadResponse {
10043 type Borrowed<'a> = &'a Self;
10044 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10045 value
10046 }
10047 }
10048
10049 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamReadResponse {
10050 type Owned = Self;
10051
10052 #[inline(always)]
10053 fn inline_align(_context: fidl::encoding::Context) -> usize {
10054 8
10055 }
10056
10057 #[inline(always)]
10058 fn inline_size(_context: fidl::encoding::Context) -> usize {
10059 16
10060 }
10061 }
10062
10063 unsafe impl<D: fidl::encoding::ResourceDialect>
10064 fidl::encoding::Encode<IsochronousStreamReadResponse, D>
10065 for &IsochronousStreamReadResponse
10066 {
10067 unsafe fn encode(
10068 self,
10069 encoder: &mut fidl::encoding::Encoder<'_, D>,
10070 offset: usize,
10071 mut depth: fidl::encoding::Depth,
10072 ) -> fidl::Result<()> {
10073 encoder.debug_check_bounds::<IsochronousStreamReadResponse>(offset);
10074 let max_ordinal: u64 = self.max_ordinal_present();
10076 encoder.write_num(max_ordinal, offset);
10077 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10078 if max_ordinal == 0 {
10080 return Ok(());
10081 }
10082 depth.increment()?;
10083 let envelope_size = 8;
10084 let bytes_len = max_ordinal as usize * envelope_size;
10085 #[allow(unused_variables)]
10086 let offset = encoder.out_of_line_offset(bytes_len);
10087 let mut _prev_end_offset: usize = 0;
10088 if 1 > max_ordinal {
10089 return Ok(());
10090 }
10091
10092 let cur_offset: usize = (1 - 1) * envelope_size;
10095
10096 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10098
10099 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10104 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10105 encoder, offset + cur_offset, depth
10106 )?;
10107
10108 _prev_end_offset = cur_offset + envelope_size;
10109 if 2 > max_ordinal {
10110 return Ok(());
10111 }
10112
10113 let cur_offset: usize = (2 - 1) * envelope_size;
10116
10117 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10119
10120 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10125 self.sequence_number.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10126 encoder,
10127 offset + cur_offset,
10128 depth,
10129 )?;
10130
10131 _prev_end_offset = cur_offset + envelope_size;
10132 if 3 > max_ordinal {
10133 return Ok(());
10134 }
10135
10136 let cur_offset: usize = (3 - 1) * envelope_size;
10139
10140 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10142
10143 fidl::encoding::encode_in_envelope_optional::<IsoPacketStatusFlag, D>(
10148 self.status_flag
10149 .as_ref()
10150 .map(<IsoPacketStatusFlag as fidl::encoding::ValueTypeMarker>::borrow),
10151 encoder,
10152 offset + cur_offset,
10153 depth,
10154 )?;
10155
10156 _prev_end_offset = cur_offset + envelope_size;
10157 if 4 > max_ordinal {
10158 return Ok(());
10159 }
10160
10161 let cur_offset: usize = (4 - 1) * envelope_size;
10164
10165 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10167
10168 fidl::encoding::encode_in_envelope_optional::<i64, D>(
10173 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10174 encoder,
10175 offset + cur_offset,
10176 depth,
10177 )?;
10178
10179 _prev_end_offset = cur_offset + envelope_size;
10180
10181 Ok(())
10182 }
10183 }
10184
10185 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10186 for IsochronousStreamReadResponse
10187 {
10188 #[inline(always)]
10189 fn new_empty() -> Self {
10190 Self::default()
10191 }
10192
10193 unsafe fn decode(
10194 &mut self,
10195 decoder: &mut fidl::encoding::Decoder<'_, D>,
10196 offset: usize,
10197 mut depth: fidl::encoding::Depth,
10198 ) -> fidl::Result<()> {
10199 decoder.debug_check_bounds::<Self>(offset);
10200 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10201 None => return Err(fidl::Error::NotNullable),
10202 Some(len) => len,
10203 };
10204 if len == 0 {
10206 return Ok(());
10207 };
10208 depth.increment()?;
10209 let envelope_size = 8;
10210 let bytes_len = len * envelope_size;
10211 let offset = decoder.out_of_line_offset(bytes_len)?;
10212 let mut _next_ordinal_to_read = 0;
10214 let mut next_offset = offset;
10215 let end_offset = offset + bytes_len;
10216 _next_ordinal_to_read += 1;
10217 if next_offset >= end_offset {
10218 return Ok(());
10219 }
10220
10221 while _next_ordinal_to_read < 1 {
10223 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10224 _next_ordinal_to_read += 1;
10225 next_offset += envelope_size;
10226 }
10227
10228 let next_out_of_line = decoder.next_out_of_line();
10229 let handles_before = decoder.remaining_handles();
10230 if let Some((inlined, num_bytes, num_handles)) =
10231 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10232 {
10233 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10234 if inlined != (member_inline_size <= 4) {
10235 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10236 }
10237 let inner_offset;
10238 let mut inner_depth = depth.clone();
10239 if inlined {
10240 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10241 inner_offset = next_offset;
10242 } else {
10243 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10244 inner_depth.increment()?;
10245 }
10246 let val_ref = self.data.get_or_insert_with(|| {
10247 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10248 });
10249 fidl::decode!(
10250 fidl::encoding::UnboundedVector<u8>,
10251 D,
10252 val_ref,
10253 decoder,
10254 inner_offset,
10255 inner_depth
10256 )?;
10257 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10258 {
10259 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10260 }
10261 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10262 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10263 }
10264 }
10265
10266 next_offset += envelope_size;
10267 _next_ordinal_to_read += 1;
10268 if next_offset >= end_offset {
10269 return Ok(());
10270 }
10271
10272 while _next_ordinal_to_read < 2 {
10274 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10275 _next_ordinal_to_read += 1;
10276 next_offset += envelope_size;
10277 }
10278
10279 let next_out_of_line = decoder.next_out_of_line();
10280 let handles_before = decoder.remaining_handles();
10281 if let Some((inlined, num_bytes, num_handles)) =
10282 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10283 {
10284 let member_inline_size =
10285 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10286 if inlined != (member_inline_size <= 4) {
10287 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10288 }
10289 let inner_offset;
10290 let mut inner_depth = depth.clone();
10291 if inlined {
10292 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10293 inner_offset = next_offset;
10294 } else {
10295 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10296 inner_depth.increment()?;
10297 }
10298 let val_ref = self.sequence_number.get_or_insert_with(|| fidl::new_empty!(u16, D));
10299 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10300 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10301 {
10302 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10303 }
10304 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10305 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10306 }
10307 }
10308
10309 next_offset += envelope_size;
10310 _next_ordinal_to_read += 1;
10311 if next_offset >= end_offset {
10312 return Ok(());
10313 }
10314
10315 while _next_ordinal_to_read < 3 {
10317 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10318 _next_ordinal_to_read += 1;
10319 next_offset += envelope_size;
10320 }
10321
10322 let next_out_of_line = decoder.next_out_of_line();
10323 let handles_before = decoder.remaining_handles();
10324 if let Some((inlined, num_bytes, num_handles)) =
10325 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10326 {
10327 let member_inline_size =
10328 <IsoPacketStatusFlag as fidl::encoding::TypeMarker>::inline_size(
10329 decoder.context,
10330 );
10331 if inlined != (member_inline_size <= 4) {
10332 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10333 }
10334 let inner_offset;
10335 let mut inner_depth = depth.clone();
10336 if inlined {
10337 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10338 inner_offset = next_offset;
10339 } else {
10340 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10341 inner_depth.increment()?;
10342 }
10343 let val_ref = self
10344 .status_flag
10345 .get_or_insert_with(|| fidl::new_empty!(IsoPacketStatusFlag, D));
10346 fidl::decode!(IsoPacketStatusFlag, D, val_ref, decoder, inner_offset, inner_depth)?;
10347 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10348 {
10349 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10350 }
10351 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10352 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10353 }
10354 }
10355
10356 next_offset += envelope_size;
10357 _next_ordinal_to_read += 1;
10358 if next_offset >= end_offset {
10359 return Ok(());
10360 }
10361
10362 while _next_ordinal_to_read < 4 {
10364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10365 _next_ordinal_to_read += 1;
10366 next_offset += envelope_size;
10367 }
10368
10369 let next_out_of_line = decoder.next_out_of_line();
10370 let handles_before = decoder.remaining_handles();
10371 if let Some((inlined, num_bytes, num_handles)) =
10372 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10373 {
10374 let member_inline_size =
10375 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10376 if inlined != (member_inline_size <= 4) {
10377 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10378 }
10379 let inner_offset;
10380 let mut inner_depth = depth.clone();
10381 if inlined {
10382 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10383 inner_offset = next_offset;
10384 } else {
10385 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10386 inner_depth.increment()?;
10387 }
10388 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
10389 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
10390 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10391 {
10392 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10393 }
10394 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10395 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10396 }
10397 }
10398
10399 next_offset += envelope_size;
10400
10401 while next_offset < end_offset {
10403 _next_ordinal_to_read += 1;
10404 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10405 next_offset += envelope_size;
10406 }
10407
10408 Ok(())
10409 }
10410 }
10411
10412 impl Legacy {
10413 #[inline(always)]
10414 fn max_ordinal_present(&self) -> u64 {
10415 0
10416 }
10417 }
10418
10419 impl fidl::encoding::ValueTypeMarker for Legacy {
10420 type Borrowed<'a> = &'a Self;
10421 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10422 value
10423 }
10424 }
10425
10426 unsafe impl fidl::encoding::TypeMarker for Legacy {
10427 type Owned = Self;
10428
10429 #[inline(always)]
10430 fn inline_align(_context: fidl::encoding::Context) -> usize {
10431 8
10432 }
10433
10434 #[inline(always)]
10435 fn inline_size(_context: fidl::encoding::Context) -> usize {
10436 16
10437 }
10438 }
10439
10440 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Legacy, D> for &Legacy {
10441 unsafe fn encode(
10442 self,
10443 encoder: &mut fidl::encoding::Encoder<'_, D>,
10444 offset: usize,
10445 mut depth: fidl::encoding::Depth,
10446 ) -> fidl::Result<()> {
10447 encoder.debug_check_bounds::<Legacy>(offset);
10448 let max_ordinal: u64 = self.max_ordinal_present();
10450 encoder.write_num(max_ordinal, offset);
10451 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10452 if max_ordinal == 0 {
10454 return Ok(());
10455 }
10456 depth.increment()?;
10457 let envelope_size = 8;
10458 let bytes_len = max_ordinal as usize * envelope_size;
10459 #[allow(unused_variables)]
10460 let offset = encoder.out_of_line_offset(bytes_len);
10461 let mut _prev_end_offset: usize = 0;
10462
10463 Ok(())
10464 }
10465 }
10466
10467 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Legacy {
10468 #[inline(always)]
10469 fn new_empty() -> Self {
10470 Self::default()
10471 }
10472
10473 unsafe fn decode(
10474 &mut self,
10475 decoder: &mut fidl::encoding::Decoder<'_, D>,
10476 offset: usize,
10477 mut depth: fidl::encoding::Depth,
10478 ) -> fidl::Result<()> {
10479 decoder.debug_check_bounds::<Self>(offset);
10480 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10481 None => return Err(fidl::Error::NotNullable),
10482 Some(len) => len,
10483 };
10484 if len == 0 {
10486 return Ok(());
10487 };
10488 depth.increment()?;
10489 let envelope_size = 8;
10490 let bytes_len = len * envelope_size;
10491 let offset = decoder.out_of_line_offset(bytes_len)?;
10492 let mut _next_ordinal_to_read = 0;
10494 let mut next_offset = offset;
10495 let end_offset = offset + bytes_len;
10496
10497 while next_offset < end_offset {
10499 _next_ordinal_to_read += 1;
10500 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10501 next_offset += envelope_size;
10502 }
10503
10504 Ok(())
10505 }
10506 }
10507
10508 impl Peer {
10509 #[inline(always)]
10510 fn max_ordinal_present(&self) -> u64 {
10511 if let Some(_) = self.periodic_advertising_interval {
10512 return 10;
10513 }
10514 if let Some(_) = self.advertising_sid {
10515 return 9;
10516 }
10517 if let Some(_) = self.last_updated {
10518 return 8;
10519 }
10520 if let Some(_) = self.bonded {
10521 return 7;
10522 }
10523 if let Some(_) = self.data {
10524 return 6;
10525 }
10526 if let Some(_) = self.name {
10527 return 5;
10528 }
10529 if let Some(_) = self.advertising_data {
10530 return 4;
10531 }
10532 if let Some(_) = self.rssi {
10533 return 3;
10534 }
10535 if let Some(_) = self.connectable {
10536 return 2;
10537 }
10538 if let Some(_) = self.id {
10539 return 1;
10540 }
10541 0
10542 }
10543 }
10544
10545 impl fidl::encoding::ValueTypeMarker for Peer {
10546 type Borrowed<'a> = &'a Self;
10547 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10548 value
10549 }
10550 }
10551
10552 unsafe impl fidl::encoding::TypeMarker for Peer {
10553 type Owned = Self;
10554
10555 #[inline(always)]
10556 fn inline_align(_context: fidl::encoding::Context) -> usize {
10557 8
10558 }
10559
10560 #[inline(always)]
10561 fn inline_size(_context: fidl::encoding::Context) -> usize {
10562 16
10563 }
10564 }
10565
10566 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Peer, D> for &Peer {
10567 unsafe fn encode(
10568 self,
10569 encoder: &mut fidl::encoding::Encoder<'_, D>,
10570 offset: usize,
10571 mut depth: fidl::encoding::Depth,
10572 ) -> fidl::Result<()> {
10573 encoder.debug_check_bounds::<Peer>(offset);
10574 let max_ordinal: u64 = self.max_ordinal_present();
10576 encoder.write_num(max_ordinal, offset);
10577 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10578 if max_ordinal == 0 {
10580 return Ok(());
10581 }
10582 depth.increment()?;
10583 let envelope_size = 8;
10584 let bytes_len = max_ordinal as usize * envelope_size;
10585 #[allow(unused_variables)]
10586 let offset = encoder.out_of_line_offset(bytes_len);
10587 let mut _prev_end_offset: usize = 0;
10588 if 1 > max_ordinal {
10589 return Ok(());
10590 }
10591
10592 let cur_offset: usize = (1 - 1) * envelope_size;
10595
10596 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10598
10599 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
10604 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
10605 encoder, offset + cur_offset, depth
10606 )?;
10607
10608 _prev_end_offset = cur_offset + envelope_size;
10609 if 2 > max_ordinal {
10610 return Ok(());
10611 }
10612
10613 let cur_offset: usize = (2 - 1) * envelope_size;
10616
10617 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10619
10620 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10625 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10626 encoder,
10627 offset + cur_offset,
10628 depth,
10629 )?;
10630
10631 _prev_end_offset = cur_offset + envelope_size;
10632 if 3 > max_ordinal {
10633 return Ok(());
10634 }
10635
10636 let cur_offset: usize = (3 - 1) * envelope_size;
10639
10640 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10642
10643 fidl::encoding::encode_in_envelope_optional::<i8, D>(
10648 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10649 encoder,
10650 offset + cur_offset,
10651 depth,
10652 )?;
10653
10654 _prev_end_offset = cur_offset + envelope_size;
10655 if 4 > max_ordinal {
10656 return Ok(());
10657 }
10658
10659 let cur_offset: usize = (4 - 1) * envelope_size;
10662
10663 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10665
10666 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
10671 self.advertising_data
10672 .as_ref()
10673 .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
10674 encoder,
10675 offset + cur_offset,
10676 depth,
10677 )?;
10678
10679 _prev_end_offset = cur_offset + envelope_size;
10680 if 5 > max_ordinal {
10681 return Ok(());
10682 }
10683
10684 let cur_offset: usize = (5 - 1) * envelope_size;
10687
10688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10690
10691 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
10696 self.name.as_ref().map(
10697 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
10698 ),
10699 encoder,
10700 offset + cur_offset,
10701 depth,
10702 )?;
10703
10704 _prev_end_offset = cur_offset + envelope_size;
10705 if 6 > max_ordinal {
10706 return Ok(());
10707 }
10708
10709 let cur_offset: usize = (6 - 1) * envelope_size;
10712
10713 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10715
10716 fidl::encoding::encode_in_envelope_optional::<ScanData, D>(
10721 self.data.as_ref().map(<ScanData as fidl::encoding::ValueTypeMarker>::borrow),
10722 encoder,
10723 offset + cur_offset,
10724 depth,
10725 )?;
10726
10727 _prev_end_offset = cur_offset + envelope_size;
10728 if 7 > max_ordinal {
10729 return Ok(());
10730 }
10731
10732 let cur_offset: usize = (7 - 1) * envelope_size;
10735
10736 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10738
10739 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10744 self.bonded.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10745 encoder,
10746 offset + cur_offset,
10747 depth,
10748 )?;
10749
10750 _prev_end_offset = cur_offset + envelope_size;
10751 if 8 > max_ordinal {
10752 return Ok(());
10753 }
10754
10755 let cur_offset: usize = (8 - 1) * envelope_size;
10758
10759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10761
10762 fidl::encoding::encode_in_envelope_optional::<i64, D>(
10767 self.last_updated.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10768 encoder,
10769 offset + cur_offset,
10770 depth,
10771 )?;
10772
10773 _prev_end_offset = cur_offset + envelope_size;
10774 if 9 > max_ordinal {
10775 return Ok(());
10776 }
10777
10778 let cur_offset: usize = (9 - 1) * envelope_size;
10781
10782 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10784
10785 fidl::encoding::encode_in_envelope_optional::<u8, D>(
10790 self.advertising_sid.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
10791 encoder,
10792 offset + cur_offset,
10793 depth,
10794 )?;
10795
10796 _prev_end_offset = cur_offset + envelope_size;
10797 if 10 > max_ordinal {
10798 return Ok(());
10799 }
10800
10801 let cur_offset: usize = (10 - 1) * envelope_size;
10804
10805 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10807
10808 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10813 self.periodic_advertising_interval
10814 .as_ref()
10815 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10816 encoder,
10817 offset + cur_offset,
10818 depth,
10819 )?;
10820
10821 _prev_end_offset = cur_offset + envelope_size;
10822
10823 Ok(())
10824 }
10825 }
10826
10827 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Peer {
10828 #[inline(always)]
10829 fn new_empty() -> Self {
10830 Self::default()
10831 }
10832
10833 unsafe fn decode(
10834 &mut self,
10835 decoder: &mut fidl::encoding::Decoder<'_, D>,
10836 offset: usize,
10837 mut depth: fidl::encoding::Depth,
10838 ) -> fidl::Result<()> {
10839 decoder.debug_check_bounds::<Self>(offset);
10840 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10841 None => return Err(fidl::Error::NotNullable),
10842 Some(len) => len,
10843 };
10844 if len == 0 {
10846 return Ok(());
10847 };
10848 depth.increment()?;
10849 let envelope_size = 8;
10850 let bytes_len = len * envelope_size;
10851 let offset = decoder.out_of_line_offset(bytes_len)?;
10852 let mut _next_ordinal_to_read = 0;
10854 let mut next_offset = offset;
10855 let end_offset = offset + bytes_len;
10856 _next_ordinal_to_read += 1;
10857 if next_offset >= end_offset {
10858 return Ok(());
10859 }
10860
10861 while _next_ordinal_to_read < 1 {
10863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10864 _next_ordinal_to_read += 1;
10865 next_offset += envelope_size;
10866 }
10867
10868 let next_out_of_line = decoder.next_out_of_line();
10869 let handles_before = decoder.remaining_handles();
10870 if let Some((inlined, num_bytes, num_handles)) =
10871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10872 {
10873 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10874 if inlined != (member_inline_size <= 4) {
10875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10876 }
10877 let inner_offset;
10878 let mut inner_depth = depth.clone();
10879 if inlined {
10880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10881 inner_offset = next_offset;
10882 } else {
10883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10884 inner_depth.increment()?;
10885 }
10886 let val_ref = self.id.get_or_insert_with(|| {
10887 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
10888 });
10889 fidl::decode!(
10890 fidl_fuchsia_bluetooth__common::PeerId,
10891 D,
10892 val_ref,
10893 decoder,
10894 inner_offset,
10895 inner_depth
10896 )?;
10897 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898 {
10899 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900 }
10901 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903 }
10904 }
10905
10906 next_offset += envelope_size;
10907 _next_ordinal_to_read += 1;
10908 if next_offset >= end_offset {
10909 return Ok(());
10910 }
10911
10912 while _next_ordinal_to_read < 2 {
10914 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915 _next_ordinal_to_read += 1;
10916 next_offset += envelope_size;
10917 }
10918
10919 let next_out_of_line = decoder.next_out_of_line();
10920 let handles_before = decoder.remaining_handles();
10921 if let Some((inlined, num_bytes, num_handles)) =
10922 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923 {
10924 let member_inline_size =
10925 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926 if inlined != (member_inline_size <= 4) {
10927 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928 }
10929 let inner_offset;
10930 let mut inner_depth = depth.clone();
10931 if inlined {
10932 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933 inner_offset = next_offset;
10934 } else {
10935 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936 inner_depth.increment()?;
10937 }
10938 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10939 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10940 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10941 {
10942 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10943 }
10944 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10945 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10946 }
10947 }
10948
10949 next_offset += envelope_size;
10950 _next_ordinal_to_read += 1;
10951 if next_offset >= end_offset {
10952 return Ok(());
10953 }
10954
10955 while _next_ordinal_to_read < 3 {
10957 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10958 _next_ordinal_to_read += 1;
10959 next_offset += envelope_size;
10960 }
10961
10962 let next_out_of_line = decoder.next_out_of_line();
10963 let handles_before = decoder.remaining_handles();
10964 if let Some((inlined, num_bytes, num_handles)) =
10965 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10966 {
10967 let member_inline_size =
10968 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10969 if inlined != (member_inline_size <= 4) {
10970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10971 }
10972 let inner_offset;
10973 let mut inner_depth = depth.clone();
10974 if inlined {
10975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10976 inner_offset = next_offset;
10977 } else {
10978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10979 inner_depth.increment()?;
10980 }
10981 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
10982 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10983 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10984 {
10985 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10986 }
10987 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10988 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10989 }
10990 }
10991
10992 next_offset += envelope_size;
10993 _next_ordinal_to_read += 1;
10994 if next_offset >= end_offset {
10995 return Ok(());
10996 }
10997
10998 while _next_ordinal_to_read < 4 {
11000 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11001 _next_ordinal_to_read += 1;
11002 next_offset += envelope_size;
11003 }
11004
11005 let next_out_of_line = decoder.next_out_of_line();
11006 let handles_before = decoder.remaining_handles();
11007 if let Some((inlined, num_bytes, num_handles)) =
11008 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11009 {
11010 let member_inline_size =
11011 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11012 if inlined != (member_inline_size <= 4) {
11013 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11014 }
11015 let inner_offset;
11016 let mut inner_depth = depth.clone();
11017 if inlined {
11018 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11019 inner_offset = next_offset;
11020 } else {
11021 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11022 inner_depth.increment()?;
11023 }
11024 let val_ref = self
11025 .advertising_data
11026 .get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
11027 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
11028 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11029 {
11030 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11031 }
11032 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11033 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11034 }
11035 }
11036
11037 next_offset += envelope_size;
11038 _next_ordinal_to_read += 1;
11039 if next_offset >= end_offset {
11040 return Ok(());
11041 }
11042
11043 while _next_ordinal_to_read < 5 {
11045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11046 _next_ordinal_to_read += 1;
11047 next_offset += envelope_size;
11048 }
11049
11050 let next_out_of_line = decoder.next_out_of_line();
11051 let handles_before = decoder.remaining_handles();
11052 if let Some((inlined, num_bytes, num_handles)) =
11053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11054 {
11055 let member_inline_size =
11056 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
11057 decoder.context,
11058 );
11059 if inlined != (member_inline_size <= 4) {
11060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11061 }
11062 let inner_offset;
11063 let mut inner_depth = depth.clone();
11064 if inlined {
11065 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11066 inner_offset = next_offset;
11067 } else {
11068 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11069 inner_depth.increment()?;
11070 }
11071 let val_ref = self
11072 .name
11073 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
11074 fidl::decode!(
11075 fidl::encoding::BoundedString<248>,
11076 D,
11077 val_ref,
11078 decoder,
11079 inner_offset,
11080 inner_depth
11081 )?;
11082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11083 {
11084 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11085 }
11086 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11087 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11088 }
11089 }
11090
11091 next_offset += envelope_size;
11092 _next_ordinal_to_read += 1;
11093 if next_offset >= end_offset {
11094 return Ok(());
11095 }
11096
11097 while _next_ordinal_to_read < 6 {
11099 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11100 _next_ordinal_to_read += 1;
11101 next_offset += envelope_size;
11102 }
11103
11104 let next_out_of_line = decoder.next_out_of_line();
11105 let handles_before = decoder.remaining_handles();
11106 if let Some((inlined, num_bytes, num_handles)) =
11107 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11108 {
11109 let member_inline_size =
11110 <ScanData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11111 if inlined != (member_inline_size <= 4) {
11112 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11113 }
11114 let inner_offset;
11115 let mut inner_depth = depth.clone();
11116 if inlined {
11117 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11118 inner_offset = next_offset;
11119 } else {
11120 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11121 inner_depth.increment()?;
11122 }
11123 let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(ScanData, D));
11124 fidl::decode!(ScanData, D, val_ref, decoder, inner_offset, inner_depth)?;
11125 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11126 {
11127 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11128 }
11129 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11130 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11131 }
11132 }
11133
11134 next_offset += envelope_size;
11135 _next_ordinal_to_read += 1;
11136 if next_offset >= end_offset {
11137 return Ok(());
11138 }
11139
11140 while _next_ordinal_to_read < 7 {
11142 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11143 _next_ordinal_to_read += 1;
11144 next_offset += envelope_size;
11145 }
11146
11147 let next_out_of_line = decoder.next_out_of_line();
11148 let handles_before = decoder.remaining_handles();
11149 if let Some((inlined, num_bytes, num_handles)) =
11150 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11151 {
11152 let member_inline_size =
11153 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11154 if inlined != (member_inline_size <= 4) {
11155 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11156 }
11157 let inner_offset;
11158 let mut inner_depth = depth.clone();
11159 if inlined {
11160 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11161 inner_offset = next_offset;
11162 } else {
11163 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11164 inner_depth.increment()?;
11165 }
11166 let val_ref = self.bonded.get_or_insert_with(|| fidl::new_empty!(bool, D));
11167 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11168 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11169 {
11170 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11171 }
11172 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11173 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11174 }
11175 }
11176
11177 next_offset += envelope_size;
11178 _next_ordinal_to_read += 1;
11179 if next_offset >= end_offset {
11180 return Ok(());
11181 }
11182
11183 while _next_ordinal_to_read < 8 {
11185 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11186 _next_ordinal_to_read += 1;
11187 next_offset += envelope_size;
11188 }
11189
11190 let next_out_of_line = decoder.next_out_of_line();
11191 let handles_before = decoder.remaining_handles();
11192 if let Some((inlined, num_bytes, num_handles)) =
11193 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11194 {
11195 let member_inline_size =
11196 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11197 if inlined != (member_inline_size <= 4) {
11198 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11199 }
11200 let inner_offset;
11201 let mut inner_depth = depth.clone();
11202 if inlined {
11203 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11204 inner_offset = next_offset;
11205 } else {
11206 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11207 inner_depth.increment()?;
11208 }
11209 let val_ref = self.last_updated.get_or_insert_with(|| fidl::new_empty!(i64, D));
11210 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11211 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11212 {
11213 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11214 }
11215 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11216 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11217 }
11218 }
11219
11220 next_offset += envelope_size;
11221 _next_ordinal_to_read += 1;
11222 if next_offset >= end_offset {
11223 return Ok(());
11224 }
11225
11226 while _next_ordinal_to_read < 9 {
11228 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11229 _next_ordinal_to_read += 1;
11230 next_offset += envelope_size;
11231 }
11232
11233 let next_out_of_line = decoder.next_out_of_line();
11234 let handles_before = decoder.remaining_handles();
11235 if let Some((inlined, num_bytes, num_handles)) =
11236 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11237 {
11238 let member_inline_size =
11239 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11240 if inlined != (member_inline_size <= 4) {
11241 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11242 }
11243 let inner_offset;
11244 let mut inner_depth = depth.clone();
11245 if inlined {
11246 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11247 inner_offset = next_offset;
11248 } else {
11249 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11250 inner_depth.increment()?;
11251 }
11252 let val_ref = self.advertising_sid.get_or_insert_with(|| fidl::new_empty!(u8, D));
11253 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
11254 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11255 {
11256 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11257 }
11258 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11259 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11260 }
11261 }
11262
11263 next_offset += envelope_size;
11264 _next_ordinal_to_read += 1;
11265 if next_offset >= end_offset {
11266 return Ok(());
11267 }
11268
11269 while _next_ordinal_to_read < 10 {
11271 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11272 _next_ordinal_to_read += 1;
11273 next_offset += envelope_size;
11274 }
11275
11276 let next_out_of_line = decoder.next_out_of_line();
11277 let handles_before = decoder.remaining_handles();
11278 if let Some((inlined, num_bytes, num_handles)) =
11279 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11280 {
11281 let member_inline_size =
11282 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11283 if inlined != (member_inline_size <= 4) {
11284 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11285 }
11286 let inner_offset;
11287 let mut inner_depth = depth.clone();
11288 if inlined {
11289 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11290 inner_offset = next_offset;
11291 } else {
11292 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11293 inner_depth.increment()?;
11294 }
11295 let val_ref = self
11296 .periodic_advertising_interval
11297 .get_or_insert_with(|| fidl::new_empty!(u16, D));
11298 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11299 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11300 {
11301 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11302 }
11303 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11304 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11305 }
11306 }
11307
11308 next_offset += envelope_size;
11309
11310 while next_offset < end_offset {
11312 _next_ordinal_to_read += 1;
11313 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11314 next_offset += envelope_size;
11315 }
11316
11317 Ok(())
11318 }
11319 }
11320
11321 impl ScanData {
11322 #[inline(always)]
11323 fn max_ordinal_present(&self) -> u64 {
11324 if let Some(_) = self.timestamp {
11325 return 7;
11326 }
11327 if let Some(_) = self.uris {
11328 return 6;
11329 }
11330 if let Some(_) = self.manufacturer_data {
11331 return 5;
11332 }
11333 if let Some(_) = self.service_data {
11334 return 4;
11335 }
11336 if let Some(_) = self.service_uuids {
11337 return 3;
11338 }
11339 if let Some(_) = self.appearance {
11340 return 2;
11341 }
11342 if let Some(_) = self.tx_power {
11343 return 1;
11344 }
11345 0
11346 }
11347 }
11348
11349 impl fidl::encoding::ValueTypeMarker for ScanData {
11350 type Borrowed<'a> = &'a Self;
11351 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11352 value
11353 }
11354 }
11355
11356 unsafe impl fidl::encoding::TypeMarker for ScanData {
11357 type Owned = Self;
11358
11359 #[inline(always)]
11360 fn inline_align(_context: fidl::encoding::Context) -> usize {
11361 8
11362 }
11363
11364 #[inline(always)]
11365 fn inline_size(_context: fidl::encoding::Context) -> usize {
11366 16
11367 }
11368 }
11369
11370 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanData, D> for &ScanData {
11371 unsafe fn encode(
11372 self,
11373 encoder: &mut fidl::encoding::Encoder<'_, D>,
11374 offset: usize,
11375 mut depth: fidl::encoding::Depth,
11376 ) -> fidl::Result<()> {
11377 encoder.debug_check_bounds::<ScanData>(offset);
11378 let max_ordinal: u64 = self.max_ordinal_present();
11380 encoder.write_num(max_ordinal, offset);
11381 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11382 if max_ordinal == 0 {
11384 return Ok(());
11385 }
11386 depth.increment()?;
11387 let envelope_size = 8;
11388 let bytes_len = max_ordinal as usize * envelope_size;
11389 #[allow(unused_variables)]
11390 let offset = encoder.out_of_line_offset(bytes_len);
11391 let mut _prev_end_offset: usize = 0;
11392 if 1 > max_ordinal {
11393 return Ok(());
11394 }
11395
11396 let cur_offset: usize = (1 - 1) * envelope_size;
11399
11400 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11402
11403 fidl::encoding::encode_in_envelope_optional::<i8, D>(
11408 self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
11409 encoder,
11410 offset + cur_offset,
11411 depth,
11412 )?;
11413
11414 _prev_end_offset = cur_offset + envelope_size;
11415 if 2 > max_ordinal {
11416 return Ok(());
11417 }
11418
11419 let cur_offset: usize = (2 - 1) * envelope_size;
11422
11423 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11425
11426 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
11431 self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
11432 encoder, offset + cur_offset, depth
11433 )?;
11434
11435 _prev_end_offset = cur_offset + envelope_size;
11436 if 3 > max_ordinal {
11437 return Ok(());
11438 }
11439
11440 let cur_offset: usize = (3 - 1) * envelope_size;
11443
11444 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11446
11447 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
11452 self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
11453 encoder, offset + cur_offset, depth
11454 )?;
11455
11456 _prev_end_offset = cur_offset + envelope_size;
11457 if 4 > max_ordinal {
11458 return Ok(());
11459 }
11460
11461 let cur_offset: usize = (4 - 1) * envelope_size;
11464
11465 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11467
11468 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
11473 self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
11474 encoder, offset + cur_offset, depth
11475 )?;
11476
11477 _prev_end_offset = cur_offset + envelope_size;
11478 if 5 > max_ordinal {
11479 return Ok(());
11480 }
11481
11482 let cur_offset: usize = (5 - 1) * envelope_size;
11485
11486 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11488
11489 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
11494 self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
11495 encoder, offset + cur_offset, depth
11496 )?;
11497
11498 _prev_end_offset = cur_offset + envelope_size;
11499 if 6 > max_ordinal {
11500 return Ok(());
11501 }
11502
11503 let cur_offset: usize = (6 - 1) * envelope_size;
11506
11507 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11509
11510 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
11515 self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
11516 encoder, offset + cur_offset, depth
11517 )?;
11518
11519 _prev_end_offset = cur_offset + envelope_size;
11520 if 7 > max_ordinal {
11521 return Ok(());
11522 }
11523
11524 let cur_offset: usize = (7 - 1) * envelope_size;
11527
11528 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11530
11531 fidl::encoding::encode_in_envelope_optional::<i64, D>(
11536 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
11537 encoder,
11538 offset + cur_offset,
11539 depth,
11540 )?;
11541
11542 _prev_end_offset = cur_offset + envelope_size;
11543
11544 Ok(())
11545 }
11546 }
11547
11548 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanData {
11549 #[inline(always)]
11550 fn new_empty() -> Self {
11551 Self::default()
11552 }
11553
11554 unsafe fn decode(
11555 &mut self,
11556 decoder: &mut fidl::encoding::Decoder<'_, D>,
11557 offset: usize,
11558 mut depth: fidl::encoding::Depth,
11559 ) -> fidl::Result<()> {
11560 decoder.debug_check_bounds::<Self>(offset);
11561 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11562 None => return Err(fidl::Error::NotNullable),
11563 Some(len) => len,
11564 };
11565 if len == 0 {
11567 return Ok(());
11568 };
11569 depth.increment()?;
11570 let envelope_size = 8;
11571 let bytes_len = len * envelope_size;
11572 let offset = decoder.out_of_line_offset(bytes_len)?;
11573 let mut _next_ordinal_to_read = 0;
11575 let mut next_offset = offset;
11576 let end_offset = offset + bytes_len;
11577 _next_ordinal_to_read += 1;
11578 if next_offset >= end_offset {
11579 return Ok(());
11580 }
11581
11582 while _next_ordinal_to_read < 1 {
11584 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11585 _next_ordinal_to_read += 1;
11586 next_offset += envelope_size;
11587 }
11588
11589 let next_out_of_line = decoder.next_out_of_line();
11590 let handles_before = decoder.remaining_handles();
11591 if let Some((inlined, num_bytes, num_handles)) =
11592 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11593 {
11594 let member_inline_size =
11595 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11596 if inlined != (member_inline_size <= 4) {
11597 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11598 }
11599 let inner_offset;
11600 let mut inner_depth = depth.clone();
11601 if inlined {
11602 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11603 inner_offset = next_offset;
11604 } else {
11605 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11606 inner_depth.increment()?;
11607 }
11608 let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
11609 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11610 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11611 {
11612 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11613 }
11614 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11615 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11616 }
11617 }
11618
11619 next_offset += envelope_size;
11620 _next_ordinal_to_read += 1;
11621 if next_offset >= end_offset {
11622 return Ok(());
11623 }
11624
11625 while _next_ordinal_to_read < 2 {
11627 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11628 _next_ordinal_to_read += 1;
11629 next_offset += envelope_size;
11630 }
11631
11632 let next_out_of_line = decoder.next_out_of_line();
11633 let handles_before = decoder.remaining_handles();
11634 if let Some((inlined, num_bytes, num_handles)) =
11635 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11636 {
11637 let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11638 if inlined != (member_inline_size <= 4) {
11639 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11640 }
11641 let inner_offset;
11642 let mut inner_depth = depth.clone();
11643 if inlined {
11644 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11645 inner_offset = next_offset;
11646 } else {
11647 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11648 inner_depth.increment()?;
11649 }
11650 let val_ref = self.appearance.get_or_insert_with(|| {
11651 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
11652 });
11653 fidl::decode!(
11654 fidl_fuchsia_bluetooth__common::Appearance,
11655 D,
11656 val_ref,
11657 decoder,
11658 inner_offset,
11659 inner_depth
11660 )?;
11661 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11662 {
11663 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11664 }
11665 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11666 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11667 }
11668 }
11669
11670 next_offset += envelope_size;
11671 _next_ordinal_to_read += 1;
11672 if next_offset >= end_offset {
11673 return Ok(());
11674 }
11675
11676 while _next_ordinal_to_read < 3 {
11678 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11679 _next_ordinal_to_read += 1;
11680 next_offset += envelope_size;
11681 }
11682
11683 let next_out_of_line = decoder.next_out_of_line();
11684 let handles_before = decoder.remaining_handles();
11685 if let Some((inlined, num_bytes, num_handles)) =
11686 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11687 {
11688 let member_inline_size = <fidl::encoding::UnboundedVector<
11689 fidl_fuchsia_bluetooth__common::Uuid,
11690 > as fidl::encoding::TypeMarker>::inline_size(
11691 decoder.context
11692 );
11693 if inlined != (member_inline_size <= 4) {
11694 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11695 }
11696 let inner_offset;
11697 let mut inner_depth = depth.clone();
11698 if inlined {
11699 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11700 inner_offset = next_offset;
11701 } else {
11702 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11703 inner_depth.increment()?;
11704 }
11705 let val_ref = self.service_uuids.get_or_insert_with(|| {
11706 fidl::new_empty!(
11707 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11708 D
11709 )
11710 });
11711 fidl::decode!(
11712 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11713 D,
11714 val_ref,
11715 decoder,
11716 inner_offset,
11717 inner_depth
11718 )?;
11719 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11720 {
11721 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11722 }
11723 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11724 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11725 }
11726 }
11727
11728 next_offset += envelope_size;
11729 _next_ordinal_to_read += 1;
11730 if next_offset >= end_offset {
11731 return Ok(());
11732 }
11733
11734 while _next_ordinal_to_read < 4 {
11736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11737 _next_ordinal_to_read += 1;
11738 next_offset += envelope_size;
11739 }
11740
11741 let next_out_of_line = decoder.next_out_of_line();
11742 let handles_before = decoder.remaining_handles();
11743 if let Some((inlined, num_bytes, num_handles)) =
11744 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11745 {
11746 let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11747 if inlined != (member_inline_size <= 4) {
11748 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11749 }
11750 let inner_offset;
11751 let mut inner_depth = depth.clone();
11752 if inlined {
11753 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11754 inner_offset = next_offset;
11755 } else {
11756 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11757 inner_depth.increment()?;
11758 }
11759 let val_ref = self.service_data.get_or_insert_with(|| {
11760 fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
11761 });
11762 fidl::decode!(
11763 fidl::encoding::UnboundedVector<ServiceData>,
11764 D,
11765 val_ref,
11766 decoder,
11767 inner_offset,
11768 inner_depth
11769 )?;
11770 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11771 {
11772 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11773 }
11774 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11775 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11776 }
11777 }
11778
11779 next_offset += envelope_size;
11780 _next_ordinal_to_read += 1;
11781 if next_offset >= end_offset {
11782 return Ok(());
11783 }
11784
11785 while _next_ordinal_to_read < 5 {
11787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11788 _next_ordinal_to_read += 1;
11789 next_offset += envelope_size;
11790 }
11791
11792 let next_out_of_line = decoder.next_out_of_line();
11793 let handles_before = decoder.remaining_handles();
11794 if let Some((inlined, num_bytes, num_handles)) =
11795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11796 {
11797 let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11798 if inlined != (member_inline_size <= 4) {
11799 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11800 }
11801 let inner_offset;
11802 let mut inner_depth = depth.clone();
11803 if inlined {
11804 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11805 inner_offset = next_offset;
11806 } else {
11807 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11808 inner_depth.increment()?;
11809 }
11810 let val_ref = self.manufacturer_data.get_or_insert_with(|| {
11811 fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
11812 });
11813 fidl::decode!(
11814 fidl::encoding::UnboundedVector<ManufacturerData>,
11815 D,
11816 val_ref,
11817 decoder,
11818 inner_offset,
11819 inner_depth
11820 )?;
11821 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11822 {
11823 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11824 }
11825 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11826 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11827 }
11828 }
11829
11830 next_offset += envelope_size;
11831 _next_ordinal_to_read += 1;
11832 if next_offset >= end_offset {
11833 return Ok(());
11834 }
11835
11836 while _next_ordinal_to_read < 6 {
11838 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11839 _next_ordinal_to_read += 1;
11840 next_offset += envelope_size;
11841 }
11842
11843 let next_out_of_line = decoder.next_out_of_line();
11844 let handles_before = decoder.remaining_handles();
11845 if let Some((inlined, num_bytes, num_handles)) =
11846 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11847 {
11848 let member_inline_size = <fidl::encoding::UnboundedVector<
11849 fidl::encoding::BoundedString<278>,
11850 > as fidl::encoding::TypeMarker>::inline_size(
11851 decoder.context
11852 );
11853 if inlined != (member_inline_size <= 4) {
11854 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11855 }
11856 let inner_offset;
11857 let mut inner_depth = depth.clone();
11858 if inlined {
11859 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11860 inner_offset = next_offset;
11861 } else {
11862 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11863 inner_depth.increment()?;
11864 }
11865 let val_ref = self.uris.get_or_insert_with(|| {
11866 fidl::new_empty!(
11867 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11868 D
11869 )
11870 });
11871 fidl::decode!(
11872 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11873 D,
11874 val_ref,
11875 decoder,
11876 inner_offset,
11877 inner_depth
11878 )?;
11879 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11880 {
11881 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11882 }
11883 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11884 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11885 }
11886 }
11887
11888 next_offset += envelope_size;
11889 _next_ordinal_to_read += 1;
11890 if next_offset >= end_offset {
11891 return Ok(());
11892 }
11893
11894 while _next_ordinal_to_read < 7 {
11896 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11897 _next_ordinal_to_read += 1;
11898 next_offset += envelope_size;
11899 }
11900
11901 let next_out_of_line = decoder.next_out_of_line();
11902 let handles_before = decoder.remaining_handles();
11903 if let Some((inlined, num_bytes, num_handles)) =
11904 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11905 {
11906 let member_inline_size =
11907 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11908 if inlined != (member_inline_size <= 4) {
11909 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11910 }
11911 let inner_offset;
11912 let mut inner_depth = depth.clone();
11913 if inlined {
11914 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11915 inner_offset = next_offset;
11916 } else {
11917 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11918 inner_depth.increment()?;
11919 }
11920 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
11921 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11922 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11923 {
11924 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11925 }
11926 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11927 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11928 }
11929 }
11930
11931 next_offset += envelope_size;
11932
11933 while next_offset < end_offset {
11935 _next_ordinal_to_read += 1;
11936 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11937 next_offset += envelope_size;
11938 }
11939
11940 Ok(())
11941 }
11942 }
11943
11944 impl ScanOptions {
11945 #[inline(always)]
11946 fn max_ordinal_present(&self) -> u64 {
11947 if let Some(_) = self.filters {
11948 return 1;
11949 }
11950 0
11951 }
11952 }
11953
11954 impl fidl::encoding::ValueTypeMarker for ScanOptions {
11955 type Borrowed<'a> = &'a Self;
11956 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11957 value
11958 }
11959 }
11960
11961 unsafe impl fidl::encoding::TypeMarker for ScanOptions {
11962 type Owned = Self;
11963
11964 #[inline(always)]
11965 fn inline_align(_context: fidl::encoding::Context) -> usize {
11966 8
11967 }
11968
11969 #[inline(always)]
11970 fn inline_size(_context: fidl::encoding::Context) -> usize {
11971 16
11972 }
11973 }
11974
11975 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanOptions, D>
11976 for &ScanOptions
11977 {
11978 unsafe fn encode(
11979 self,
11980 encoder: &mut fidl::encoding::Encoder<'_, D>,
11981 offset: usize,
11982 mut depth: fidl::encoding::Depth,
11983 ) -> fidl::Result<()> {
11984 encoder.debug_check_bounds::<ScanOptions>(offset);
11985 let max_ordinal: u64 = self.max_ordinal_present();
11987 encoder.write_num(max_ordinal, offset);
11988 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11989 if max_ordinal == 0 {
11991 return Ok(());
11992 }
11993 depth.increment()?;
11994 let envelope_size = 8;
11995 let bytes_len = max_ordinal as usize * envelope_size;
11996 #[allow(unused_variables)]
11997 let offset = encoder.out_of_line_offset(bytes_len);
11998 let mut _prev_end_offset: usize = 0;
11999 if 1 > max_ordinal {
12000 return Ok(());
12001 }
12002
12003 let cur_offset: usize = (1 - 1) * envelope_size;
12006
12007 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12009
12010 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Filter>, D>(
12015 self.filters.as_ref().map(<fidl::encoding::UnboundedVector<Filter> as fidl::encoding::ValueTypeMarker>::borrow),
12016 encoder, offset + cur_offset, depth
12017 )?;
12018
12019 _prev_end_offset = cur_offset + envelope_size;
12020
12021 Ok(())
12022 }
12023 }
12024
12025 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanOptions {
12026 #[inline(always)]
12027 fn new_empty() -> Self {
12028 Self::default()
12029 }
12030
12031 unsafe fn decode(
12032 &mut self,
12033 decoder: &mut fidl::encoding::Decoder<'_, D>,
12034 offset: usize,
12035 mut depth: fidl::encoding::Depth,
12036 ) -> fidl::Result<()> {
12037 decoder.debug_check_bounds::<Self>(offset);
12038 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12039 None => return Err(fidl::Error::NotNullable),
12040 Some(len) => len,
12041 };
12042 if len == 0 {
12044 return Ok(());
12045 };
12046 depth.increment()?;
12047 let envelope_size = 8;
12048 let bytes_len = len * envelope_size;
12049 let offset = decoder.out_of_line_offset(bytes_len)?;
12050 let mut _next_ordinal_to_read = 0;
12052 let mut next_offset = offset;
12053 let end_offset = offset + bytes_len;
12054 _next_ordinal_to_read += 1;
12055 if next_offset >= end_offset {
12056 return Ok(());
12057 }
12058
12059 while _next_ordinal_to_read < 1 {
12061 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12062 _next_ordinal_to_read += 1;
12063 next_offset += envelope_size;
12064 }
12065
12066 let next_out_of_line = decoder.next_out_of_line();
12067 let handles_before = decoder.remaining_handles();
12068 if let Some((inlined, num_bytes, num_handles)) =
12069 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12070 {
12071 let member_inline_size = <fidl::encoding::UnboundedVector<Filter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12072 if inlined != (member_inline_size <= 4) {
12073 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12074 }
12075 let inner_offset;
12076 let mut inner_depth = depth.clone();
12077 if inlined {
12078 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12079 inner_offset = next_offset;
12080 } else {
12081 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12082 inner_depth.increment()?;
12083 }
12084 let val_ref = self.filters.get_or_insert_with(|| {
12085 fidl::new_empty!(fidl::encoding::UnboundedVector<Filter>, D)
12086 });
12087 fidl::decode!(
12088 fidl::encoding::UnboundedVector<Filter>,
12089 D,
12090 val_ref,
12091 decoder,
12092 inner_offset,
12093 inner_depth
12094 )?;
12095 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12096 {
12097 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12098 }
12099 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12100 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12101 }
12102 }
12103
12104 next_offset += envelope_size;
12105
12106 while next_offset < end_offset {
12108 _next_ordinal_to_read += 1;
12109 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12110 next_offset += envelope_size;
12111 }
12112
12113 Ok(())
12114 }
12115 }
12116
12117 impl fidl::encoding::ValueTypeMarker for AdvertisingProcedure {
12118 type Borrowed<'a> = &'a Self;
12119 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12120 value
12121 }
12122 }
12123
12124 unsafe impl fidl::encoding::TypeMarker for AdvertisingProcedure {
12125 type Owned = Self;
12126
12127 #[inline(always)]
12128 fn inline_align(_context: fidl::encoding::Context) -> usize {
12129 8
12130 }
12131
12132 #[inline(always)]
12133 fn inline_size(_context: fidl::encoding::Context) -> usize {
12134 16
12135 }
12136 }
12137
12138 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingProcedure, D>
12139 for &AdvertisingProcedure
12140 {
12141 #[inline]
12142 unsafe fn encode(
12143 self,
12144 encoder: &mut fidl::encoding::Encoder<'_, D>,
12145 offset: usize,
12146 _depth: fidl::encoding::Depth,
12147 ) -> fidl::Result<()> {
12148 encoder.debug_check_bounds::<AdvertisingProcedure>(offset);
12149 encoder.write_num::<u64>(self.ordinal(), offset);
12150 match self {
12151 AdvertisingProcedure::Legacy(ref val) => {
12152 fidl::encoding::encode_in_envelope::<Legacy, D>(
12153 <Legacy as fidl::encoding::ValueTypeMarker>::borrow(val),
12154 encoder,
12155 offset + 8,
12156 _depth,
12157 )
12158 }
12159 AdvertisingProcedure::Extended(ref val) => {
12160 fidl::encoding::encode_in_envelope::<Extended, D>(
12161 <Extended as fidl::encoding::ValueTypeMarker>::borrow(val),
12162 encoder,
12163 offset + 8,
12164 _depth,
12165 )
12166 }
12167 AdvertisingProcedure::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
12168 }
12169 }
12170 }
12171
12172 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingProcedure {
12173 #[inline(always)]
12174 fn new_empty() -> Self {
12175 Self::__SourceBreaking { unknown_ordinal: 0 }
12176 }
12177
12178 #[inline]
12179 unsafe fn decode(
12180 &mut self,
12181 decoder: &mut fidl::encoding::Decoder<'_, D>,
12182 offset: usize,
12183 mut depth: fidl::encoding::Depth,
12184 ) -> fidl::Result<()> {
12185 decoder.debug_check_bounds::<Self>(offset);
12186 #[allow(unused_variables)]
12187 let next_out_of_line = decoder.next_out_of_line();
12188 let handles_before = decoder.remaining_handles();
12189 let (ordinal, inlined, num_bytes, num_handles) =
12190 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12191
12192 let member_inline_size = match ordinal {
12193 1 => <Legacy as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12194 2 => <Extended as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12195 0 => return Err(fidl::Error::UnknownUnionTag),
12196 _ => num_bytes as usize,
12197 };
12198
12199 if inlined != (member_inline_size <= 4) {
12200 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12201 }
12202 let _inner_offset;
12203 if inlined {
12204 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12205 _inner_offset = offset + 8;
12206 } else {
12207 depth.increment()?;
12208 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12209 }
12210 match ordinal {
12211 1 => {
12212 #[allow(irrefutable_let_patterns)]
12213 if let AdvertisingProcedure::Legacy(_) = self {
12214 } else {
12216 *self = AdvertisingProcedure::Legacy(fidl::new_empty!(Legacy, D));
12218 }
12219 #[allow(irrefutable_let_patterns)]
12220 if let AdvertisingProcedure::Legacy(ref mut val) = self {
12221 fidl::decode!(Legacy, D, val, decoder, _inner_offset, depth)?;
12222 } else {
12223 unreachable!()
12224 }
12225 }
12226 2 => {
12227 #[allow(irrefutable_let_patterns)]
12228 if let AdvertisingProcedure::Extended(_) = self {
12229 } else {
12231 *self = AdvertisingProcedure::Extended(fidl::new_empty!(Extended, D));
12233 }
12234 #[allow(irrefutable_let_patterns)]
12235 if let AdvertisingProcedure::Extended(ref mut val) = self {
12236 fidl::decode!(Extended, D, val, decoder, _inner_offset, depth)?;
12237 } else {
12238 unreachable!()
12239 }
12240 }
12241 #[allow(deprecated)]
12242 ordinal => {
12243 for _ in 0..num_handles {
12244 decoder.drop_next_handle()?;
12245 }
12246 *self = AdvertisingProcedure::__SourceBreaking { unknown_ordinal: ordinal };
12247 }
12248 }
12249 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12250 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12251 }
12252 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12253 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12254 }
12255 Ok(())
12256 }
12257 }
12258}