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
1160pub mod advertised_peripheral_ordinals {
1161 pub const ON_CONNECTED: u64 = 0x607b7716457eb178;
1162}
1163
1164pub mod advertising_handle_ordinals {}
1165
1166pub mod central_ordinals {
1167 pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1168 pub const SCAN: u64 = 0x41f7121798dfe15f;
1169 pub const CONNECT: u64 = 0x31a3065f2a6913c4;
1170 pub const CREATE_CONNECTED_ISOCHRONOUS_GROUP: u64 = 0x60323e70ae22e13;
1171 pub const GET_PERIPHERALS: u64 = 0x37ba777499c683a8;
1172 pub const GET_PERIPHERAL: u64 = 0x97f5a2f2d9c13da;
1173 pub const START_SCAN: u64 = 0xeb4cf0cd0e1132b;
1174 pub const STOP_SCAN: u64 = 0x5f79ee6a0bb037a0;
1175 pub const CONNECT_PERIPHERAL: u64 = 0x714d6c32d066d75a;
1176 pub const DISCONNECT_PERIPHERAL: u64 = 0xa9430da197362fd;
1177 pub const ON_SCAN_STATE_CHANGED: u64 = 0x5f8edc23cad04d3f;
1178 pub const ON_DEVICE_DISCOVERED: u64 = 0x708dadf20d66db6;
1179 pub const ON_PERIPHERAL_DISCONNECTED: u64 = 0x4e4c6b979b2126df;
1180}
1181
1182pub mod channel_listener_ordinals {
1183 pub const ACCEPT: u64 = 0x6f535bd36b20fc7b;
1184}
1185
1186pub mod channel_listener_registry_ordinals {
1187 pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1188}
1189
1190pub mod codec_delay_ordinals {
1191 pub const GET_CODEC_LOCAL_DELAY_RANGE: u64 = 0x1cf34fdeed80b4d;
1192}
1193
1194pub mod connected_isochronous_group_ordinals {
1195 pub const ESTABLISH_STREAMS: u64 = 0xc7296c5edb4dacc;
1196 pub const REMOVE: u64 = 0xbed433babd20503;
1197}
1198
1199pub mod connection_ordinals {
1200 pub const GET_CODEC_LOCAL_DELAY_RANGE: u64 = 0x1cf34fdeed80b4d;
1201 pub const REQUEST_GATT_CLIENT: u64 = 0x2a670e0fec6ccc6b;
1202 pub const ACCEPT_CIS: u64 = 0x7e6338c237088144;
1203 pub const CONNECT_L2CAP: u64 = 0x12351316feaebce9;
1204}
1205
1206pub mod isochronous_stream_ordinals {
1207 pub const ON_ESTABLISHED: u64 = 0x341c50e9d10f3421;
1208 pub const SETUP_DATA_PATH: u64 = 0x7ec1e2b9cc6d2fbe;
1209 pub const READ: u64 = 0x6d7d8b4950ed3a32;
1210 pub const WRITE: u64 = 0x5282e90b667d0d43;
1211}
1212
1213pub mod peripheral_ordinals {
1214 pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1215 pub const ADVERTISE: u64 = 0x2d9ec9260c32c17f;
1216 pub const START_ADVERTISING: u64 = 0x5875c1c575f00f7d;
1217 pub const ON_PEER_CONNECTED: u64 = 0x16135d464299e356;
1218}
1219
1220pub mod privileged_peripheral_ordinals {
1221 pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1222 pub const ADVERTISE: u64 = 0x2d9ec9260c32c17f;
1223 pub const START_ADVERTISING: u64 = 0x5875c1c575f00f7d;
1224 pub const ON_PEER_CONNECTED: u64 = 0x16135d464299e356;
1225}
1226
1227pub mod scan_result_watcher_ordinals {
1228 pub const WATCH: u64 = 0x713a122e949f301a;
1229}
1230
1231mod internal {
1232 use super::*;
1233 unsafe impl fidl::encoding::TypeMarker for AdvertisingModeHint {
1234 type Owned = Self;
1235
1236 #[inline(always)]
1237 fn inline_align(_context: fidl::encoding::Context) -> usize {
1238 std::mem::align_of::<u8>()
1239 }
1240
1241 #[inline(always)]
1242 fn inline_size(_context: fidl::encoding::Context) -> usize {
1243 std::mem::size_of::<u8>()
1244 }
1245
1246 #[inline(always)]
1247 fn encode_is_copy() -> bool {
1248 true
1249 }
1250
1251 #[inline(always)]
1252 fn decode_is_copy() -> bool {
1253 false
1254 }
1255 }
1256
1257 impl fidl::encoding::ValueTypeMarker for AdvertisingModeHint {
1258 type Borrowed<'a> = Self;
1259 #[inline(always)]
1260 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1261 *value
1262 }
1263 }
1264
1265 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1266 for AdvertisingModeHint
1267 {
1268 #[inline]
1269 unsafe fn encode(
1270 self,
1271 encoder: &mut fidl::encoding::Encoder<'_, D>,
1272 offset: usize,
1273 _depth: fidl::encoding::Depth,
1274 ) -> fidl::Result<()> {
1275 encoder.debug_check_bounds::<Self>(offset);
1276 encoder.write_num(self.into_primitive(), offset);
1277 Ok(())
1278 }
1279 }
1280
1281 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingModeHint {
1282 #[inline(always)]
1283 fn new_empty() -> Self {
1284 Self::VeryFast
1285 }
1286
1287 #[inline]
1288 unsafe fn decode(
1289 &mut self,
1290 decoder: &mut fidl::encoding::Decoder<'_, D>,
1291 offset: usize,
1292 _depth: fidl::encoding::Depth,
1293 ) -> fidl::Result<()> {
1294 decoder.debug_check_bounds::<Self>(offset);
1295 let prim = decoder.read_num::<u8>(offset);
1296
1297 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1298 Ok(())
1299 }
1300 }
1301 unsafe impl fidl::encoding::TypeMarker for CentralError {
1302 type Owned = Self;
1303
1304 #[inline(always)]
1305 fn inline_align(_context: fidl::encoding::Context) -> usize {
1306 std::mem::align_of::<u32>()
1307 }
1308
1309 #[inline(always)]
1310 fn inline_size(_context: fidl::encoding::Context) -> usize {
1311 std::mem::size_of::<u32>()
1312 }
1313
1314 #[inline(always)]
1315 fn encode_is_copy() -> bool {
1316 true
1317 }
1318
1319 #[inline(always)]
1320 fn decode_is_copy() -> bool {
1321 false
1322 }
1323 }
1324
1325 impl fidl::encoding::ValueTypeMarker for CentralError {
1326 type Borrowed<'a> = Self;
1327 #[inline(always)]
1328 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1329 *value
1330 }
1331 }
1332
1333 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CentralError {
1334 #[inline]
1335 unsafe fn encode(
1336 self,
1337 encoder: &mut fidl::encoding::Encoder<'_, D>,
1338 offset: usize,
1339 _depth: fidl::encoding::Depth,
1340 ) -> fidl::Result<()> {
1341 encoder.debug_check_bounds::<Self>(offset);
1342 encoder.write_num(self.into_primitive(), offset);
1343 Ok(())
1344 }
1345 }
1346
1347 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CentralError {
1348 #[inline(always)]
1349 fn new_empty() -> Self {
1350 Self::Aborted
1351 }
1352
1353 #[inline]
1354 unsafe fn decode(
1355 &mut self,
1356 decoder: &mut fidl::encoding::Decoder<'_, D>,
1357 offset: usize,
1358 _depth: fidl::encoding::Depth,
1359 ) -> fidl::Result<()> {
1360 decoder.debug_check_bounds::<Self>(offset);
1361 let prim = decoder.read_num::<u32>(offset);
1362
1363 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1364 Ok(())
1365 }
1366 }
1367 unsafe impl fidl::encoding::TypeMarker for CigFramingOptions {
1368 type Owned = Self;
1369
1370 #[inline(always)]
1371 fn inline_align(_context: fidl::encoding::Context) -> usize {
1372 std::mem::align_of::<u32>()
1373 }
1374
1375 #[inline(always)]
1376 fn inline_size(_context: fidl::encoding::Context) -> usize {
1377 std::mem::size_of::<u32>()
1378 }
1379
1380 #[inline(always)]
1381 fn encode_is_copy() -> bool {
1382 true
1383 }
1384
1385 #[inline(always)]
1386 fn decode_is_copy() -> bool {
1387 false
1388 }
1389 }
1390
1391 impl fidl::encoding::ValueTypeMarker for CigFramingOptions {
1392 type Borrowed<'a> = Self;
1393 #[inline(always)]
1394 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1395 *value
1396 }
1397 }
1398
1399 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1400 for CigFramingOptions
1401 {
1402 #[inline]
1403 unsafe fn encode(
1404 self,
1405 encoder: &mut fidl::encoding::Encoder<'_, D>,
1406 offset: usize,
1407 _depth: fidl::encoding::Depth,
1408 ) -> fidl::Result<()> {
1409 encoder.debug_check_bounds::<Self>(offset);
1410 encoder.write_num(self.into_primitive(), offset);
1411 Ok(())
1412 }
1413 }
1414
1415 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigFramingOptions {
1416 #[inline(always)]
1417 fn new_empty() -> Self {
1418 Self::Unframed
1419 }
1420
1421 #[inline]
1422 unsafe fn decode(
1423 &mut self,
1424 decoder: &mut fidl::encoding::Decoder<'_, D>,
1425 offset: usize,
1426 _depth: fidl::encoding::Depth,
1427 ) -> fidl::Result<()> {
1428 decoder.debug_check_bounds::<Self>(offset);
1429 let prim = decoder.read_num::<u32>(offset);
1430
1431 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1432 Ok(())
1433 }
1434 }
1435 unsafe impl fidl::encoding::TypeMarker for CigPacking {
1436 type Owned = Self;
1437
1438 #[inline(always)]
1439 fn inline_align(_context: fidl::encoding::Context) -> usize {
1440 std::mem::align_of::<u32>()
1441 }
1442
1443 #[inline(always)]
1444 fn inline_size(_context: fidl::encoding::Context) -> usize {
1445 std::mem::size_of::<u32>()
1446 }
1447
1448 #[inline(always)]
1449 fn encode_is_copy() -> bool {
1450 false
1451 }
1452
1453 #[inline(always)]
1454 fn decode_is_copy() -> bool {
1455 false
1456 }
1457 }
1458
1459 impl fidl::encoding::ValueTypeMarker for CigPacking {
1460 type Borrowed<'a> = Self;
1461 #[inline(always)]
1462 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1463 *value
1464 }
1465 }
1466
1467 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CigPacking {
1468 #[inline]
1469 unsafe fn encode(
1470 self,
1471 encoder: &mut fidl::encoding::Encoder<'_, D>,
1472 offset: usize,
1473 _depth: fidl::encoding::Depth,
1474 ) -> fidl::Result<()> {
1475 encoder.debug_check_bounds::<Self>(offset);
1476 encoder.write_num(self.into_primitive(), offset);
1477 Ok(())
1478 }
1479 }
1480
1481 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigPacking {
1482 #[inline(always)]
1483 fn new_empty() -> Self {
1484 Self::unknown()
1485 }
1486
1487 #[inline]
1488 unsafe fn decode(
1489 &mut self,
1490 decoder: &mut fidl::encoding::Decoder<'_, D>,
1491 offset: usize,
1492 _depth: fidl::encoding::Depth,
1493 ) -> fidl::Result<()> {
1494 decoder.debug_check_bounds::<Self>(offset);
1495 let prim = decoder.read_num::<u32>(offset);
1496
1497 *self = Self::from_primitive_allow_unknown(prim);
1498 Ok(())
1499 }
1500 }
1501 unsafe impl fidl::encoding::TypeMarker for CreateCigError {
1502 type Owned = Self;
1503
1504 #[inline(always)]
1505 fn inline_align(_context: fidl::encoding::Context) -> usize {
1506 std::mem::align_of::<u32>()
1507 }
1508
1509 #[inline(always)]
1510 fn inline_size(_context: fidl::encoding::Context) -> usize {
1511 std::mem::size_of::<u32>()
1512 }
1513
1514 #[inline(always)]
1515 fn encode_is_copy() -> bool {
1516 false
1517 }
1518
1519 #[inline(always)]
1520 fn decode_is_copy() -> bool {
1521 false
1522 }
1523 }
1524
1525 impl fidl::encoding::ValueTypeMarker for CreateCigError {
1526 type Borrowed<'a> = Self;
1527 #[inline(always)]
1528 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1529 *value
1530 }
1531 }
1532
1533 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateCigError {
1534 #[inline]
1535 unsafe fn encode(
1536 self,
1537 encoder: &mut fidl::encoding::Encoder<'_, D>,
1538 offset: usize,
1539 _depth: fidl::encoding::Depth,
1540 ) -> fidl::Result<()> {
1541 encoder.debug_check_bounds::<Self>(offset);
1542 encoder.write_num(self.into_primitive(), offset);
1543 Ok(())
1544 }
1545 }
1546
1547 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateCigError {
1548 #[inline(always)]
1549 fn new_empty() -> Self {
1550 Self::unknown()
1551 }
1552
1553 #[inline]
1554 unsafe fn decode(
1555 &mut self,
1556 decoder: &mut fidl::encoding::Decoder<'_, D>,
1557 offset: usize,
1558 _depth: fidl::encoding::Depth,
1559 ) -> fidl::Result<()> {
1560 decoder.debug_check_bounds::<Self>(offset);
1561 let prim = decoder.read_num::<u32>(offset);
1562
1563 *self = Self::from_primitive_allow_unknown(prim);
1564 Ok(())
1565 }
1566 }
1567 unsafe impl fidl::encoding::TypeMarker for EstablishStreamsError {
1568 type Owned = Self;
1569
1570 #[inline(always)]
1571 fn inline_align(_context: fidl::encoding::Context) -> usize {
1572 std::mem::align_of::<u32>()
1573 }
1574
1575 #[inline(always)]
1576 fn inline_size(_context: fidl::encoding::Context) -> usize {
1577 std::mem::size_of::<u32>()
1578 }
1579
1580 #[inline(always)]
1581 fn encode_is_copy() -> bool {
1582 false
1583 }
1584
1585 #[inline(always)]
1586 fn decode_is_copy() -> bool {
1587 false
1588 }
1589 }
1590
1591 impl fidl::encoding::ValueTypeMarker for EstablishStreamsError {
1592 type Borrowed<'a> = Self;
1593 #[inline(always)]
1594 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1595 *value
1596 }
1597 }
1598
1599 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1600 for EstablishStreamsError
1601 {
1602 #[inline]
1603 unsafe fn encode(
1604 self,
1605 encoder: &mut fidl::encoding::Encoder<'_, D>,
1606 offset: usize,
1607 _depth: fidl::encoding::Depth,
1608 ) -> fidl::Result<()> {
1609 encoder.debug_check_bounds::<Self>(offset);
1610 encoder.write_num(self.into_primitive(), offset);
1611 Ok(())
1612 }
1613 }
1614
1615 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EstablishStreamsError {
1616 #[inline(always)]
1617 fn new_empty() -> Self {
1618 Self::unknown()
1619 }
1620
1621 #[inline]
1622 unsafe fn decode(
1623 &mut self,
1624 decoder: &mut fidl::encoding::Decoder<'_, D>,
1625 offset: usize,
1626 _depth: fidl::encoding::Depth,
1627 ) -> fidl::Result<()> {
1628 decoder.debug_check_bounds::<Self>(offset);
1629 let prim = decoder.read_num::<u32>(offset);
1630
1631 *self = Self::from_primitive_allow_unknown(prim);
1632 Ok(())
1633 }
1634 }
1635 unsafe impl fidl::encoding::TypeMarker for IsoPacketStatusFlag {
1636 type Owned = Self;
1637
1638 #[inline(always)]
1639 fn inline_align(_context: fidl::encoding::Context) -> usize {
1640 std::mem::align_of::<u8>()
1641 }
1642
1643 #[inline(always)]
1644 fn inline_size(_context: fidl::encoding::Context) -> usize {
1645 std::mem::size_of::<u8>()
1646 }
1647
1648 #[inline(always)]
1649 fn encode_is_copy() -> bool {
1650 true
1651 }
1652
1653 #[inline(always)]
1654 fn decode_is_copy() -> bool {
1655 false
1656 }
1657 }
1658
1659 impl fidl::encoding::ValueTypeMarker for IsoPacketStatusFlag {
1660 type Borrowed<'a> = Self;
1661 #[inline(always)]
1662 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1663 *value
1664 }
1665 }
1666
1667 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1668 for IsoPacketStatusFlag
1669 {
1670 #[inline]
1671 unsafe fn encode(
1672 self,
1673 encoder: &mut fidl::encoding::Encoder<'_, D>,
1674 offset: usize,
1675 _depth: fidl::encoding::Depth,
1676 ) -> fidl::Result<()> {
1677 encoder.debug_check_bounds::<Self>(offset);
1678 encoder.write_num(self.into_primitive(), offset);
1679 Ok(())
1680 }
1681 }
1682
1683 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IsoPacketStatusFlag {
1684 #[inline(always)]
1685 fn new_empty() -> Self {
1686 Self::ValidData
1687 }
1688
1689 #[inline]
1690 unsafe fn decode(
1691 &mut self,
1692 decoder: &mut fidl::encoding::Decoder<'_, D>,
1693 offset: usize,
1694 _depth: fidl::encoding::Depth,
1695 ) -> fidl::Result<()> {
1696 decoder.debug_check_bounds::<Self>(offset);
1697 let prim = decoder.read_num::<u8>(offset);
1698
1699 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1700 Ok(())
1701 }
1702 }
1703 unsafe impl fidl::encoding::TypeMarker for PeripheralError {
1704 type Owned = Self;
1705
1706 #[inline(always)]
1707 fn inline_align(_context: fidl::encoding::Context) -> usize {
1708 std::mem::align_of::<u32>()
1709 }
1710
1711 #[inline(always)]
1712 fn inline_size(_context: fidl::encoding::Context) -> usize {
1713 std::mem::size_of::<u32>()
1714 }
1715
1716 #[inline(always)]
1717 fn encode_is_copy() -> bool {
1718 true
1719 }
1720
1721 #[inline(always)]
1722 fn decode_is_copy() -> bool {
1723 false
1724 }
1725 }
1726
1727 impl fidl::encoding::ValueTypeMarker for PeripheralError {
1728 type Borrowed<'a> = Self;
1729 #[inline(always)]
1730 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1731 *value
1732 }
1733 }
1734
1735 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1736 for PeripheralError
1737 {
1738 #[inline]
1739 unsafe fn encode(
1740 self,
1741 encoder: &mut fidl::encoding::Encoder<'_, D>,
1742 offset: usize,
1743 _depth: fidl::encoding::Depth,
1744 ) -> fidl::Result<()> {
1745 encoder.debug_check_bounds::<Self>(offset);
1746 encoder.write_num(self.into_primitive(), offset);
1747 Ok(())
1748 }
1749 }
1750
1751 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeripheralError {
1752 #[inline(always)]
1753 fn new_empty() -> Self {
1754 Self::NotSupported
1755 }
1756
1757 #[inline]
1758 unsafe fn decode(
1759 &mut self,
1760 decoder: &mut fidl::encoding::Decoder<'_, D>,
1761 offset: usize,
1762 _depth: fidl::encoding::Depth,
1763 ) -> fidl::Result<()> {
1764 decoder.debug_check_bounds::<Self>(offset);
1765 let prim = decoder.read_num::<u32>(offset);
1766
1767 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1768 Ok(())
1769 }
1770 }
1771
1772 impl fidl::encoding::ValueTypeMarker for AdvertisingDataDeprecated {
1773 type Borrowed<'a> = &'a Self;
1774 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1775 value
1776 }
1777 }
1778
1779 unsafe impl fidl::encoding::TypeMarker for AdvertisingDataDeprecated {
1780 type Owned = Self;
1781
1782 #[inline(always)]
1783 fn inline_align(_context: fidl::encoding::Context) -> usize {
1784 8
1785 }
1786
1787 #[inline(always)]
1788 fn inline_size(_context: fidl::encoding::Context) -> usize {
1789 112
1790 }
1791 }
1792
1793 unsafe impl<D: fidl::encoding::ResourceDialect>
1794 fidl::encoding::Encode<AdvertisingDataDeprecated, D> for &AdvertisingDataDeprecated
1795 {
1796 #[inline]
1797 unsafe fn encode(
1798 self,
1799 encoder: &mut fidl::encoding::Encoder<'_, D>,
1800 offset: usize,
1801 _depth: fidl::encoding::Depth,
1802 ) -> fidl::Result<()> {
1803 encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1804 fidl::encoding::Encode::<AdvertisingDataDeprecated, D>::encode(
1806 (
1807 <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1808 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.tx_power_level),
1809 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.appearance),
1810 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
1811 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data),
1812 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_specific_data),
1813 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.solicited_service_uuids),
1814 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>> as fidl::encoding::ValueTypeMarker>::borrow(&self.uris),
1815 ),
1816 encoder, offset, _depth
1817 )
1818 }
1819 }
1820 unsafe impl<
1821 D: fidl::encoding::ResourceDialect,
1822 T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
1823 T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
1824 T2: fidl::encoding::Encode<
1825 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1826 D,
1827 >,
1828 T3: fidl::encoding::Encode<
1829 fidl::encoding::Optional<
1830 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1831 >,
1832 D,
1833 >,
1834 T4: fidl::encoding::Encode<
1835 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1836 D,
1837 >,
1838 T5: fidl::encoding::Encode<
1839 fidl::encoding::Optional<
1840 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1841 >,
1842 D,
1843 >,
1844 T6: fidl::encoding::Encode<
1845 fidl::encoding::Optional<
1846 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1847 >,
1848 D,
1849 >,
1850 T7: fidl::encoding::Encode<
1851 fidl::encoding::Optional<
1852 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1853 >,
1854 D,
1855 >,
1856 > fidl::encoding::Encode<AdvertisingDataDeprecated, D>
1857 for (T0, T1, T2, T3, T4, T5, T6, T7)
1858 {
1859 #[inline]
1860 unsafe fn encode(
1861 self,
1862 encoder: &mut fidl::encoding::Encoder<'_, D>,
1863 offset: usize,
1864 depth: fidl::encoding::Depth,
1865 ) -> fidl::Result<()> {
1866 encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1867 self.0.encode(encoder, offset + 0, depth)?;
1871 self.1.encode(encoder, offset + 16, depth)?;
1872 self.2.encode(encoder, offset + 24, depth)?;
1873 self.3.encode(encoder, offset + 32, depth)?;
1874 self.4.encode(encoder, offset + 48, depth)?;
1875 self.5.encode(encoder, offset + 64, depth)?;
1876 self.6.encode(encoder, offset + 80, depth)?;
1877 self.7.encode(encoder, offset + 96, depth)?;
1878 Ok(())
1879 }
1880 }
1881
1882 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1883 for AdvertisingDataDeprecated
1884 {
1885 #[inline(always)]
1886 fn new_empty() -> Self {
1887 Self {
1888 name: fidl::new_empty!(
1889 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1890 D
1891 ),
1892 tx_power_level: fidl::new_empty!(
1893 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1894 D
1895 ),
1896 appearance: fidl::new_empty!(
1897 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1898 D
1899 ),
1900 service_uuids: fidl::new_empty!(
1901 fidl::encoding::Optional<
1902 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1903 >,
1904 D
1905 ),
1906 service_data: fidl::new_empty!(
1907 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1908 D
1909 ),
1910 manufacturer_specific_data: fidl::new_empty!(
1911 fidl::encoding::Optional<
1912 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1913 >,
1914 D
1915 ),
1916 solicited_service_uuids: fidl::new_empty!(
1917 fidl::encoding::Optional<
1918 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1919 >,
1920 D
1921 ),
1922 uris: fidl::new_empty!(
1923 fidl::encoding::Optional<
1924 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1925 >,
1926 D
1927 ),
1928 }
1929 }
1930
1931 #[inline]
1932 unsafe fn decode(
1933 &mut self,
1934 decoder: &mut fidl::encoding::Decoder<'_, D>,
1935 offset: usize,
1936 _depth: fidl::encoding::Depth,
1937 ) -> fidl::Result<()> {
1938 decoder.debug_check_bounds::<Self>(offset);
1939 fidl::decode!(
1941 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1942 D,
1943 &mut self.name,
1944 decoder,
1945 offset + 0,
1946 _depth
1947 )?;
1948 fidl::decode!(
1949 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1950 D,
1951 &mut self.tx_power_level,
1952 decoder,
1953 offset + 16,
1954 _depth
1955 )?;
1956 fidl::decode!(
1957 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1958 D,
1959 &mut self.appearance,
1960 decoder,
1961 offset + 24,
1962 _depth
1963 )?;
1964 fidl::decode!(
1965 fidl::encoding::Optional<
1966 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1967 >,
1968 D,
1969 &mut self.service_uuids,
1970 decoder,
1971 offset + 32,
1972 _depth
1973 )?;
1974 fidl::decode!(
1975 fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1976 D,
1977 &mut self.service_data,
1978 decoder,
1979 offset + 48,
1980 _depth
1981 )?;
1982 fidl::decode!(
1983 fidl::encoding::Optional<
1984 fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1985 >,
1986 D,
1987 &mut self.manufacturer_specific_data,
1988 decoder,
1989 offset + 64,
1990 _depth
1991 )?;
1992 fidl::decode!(
1993 fidl::encoding::Optional<
1994 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1995 >,
1996 D,
1997 &mut self.solicited_service_uuids,
1998 decoder,
1999 offset + 80,
2000 _depth
2001 )?;
2002 fidl::decode!(
2003 fidl::encoding::Optional<
2004 fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2005 >,
2006 D,
2007 &mut self.uris,
2008 decoder,
2009 offset + 96,
2010 _depth
2011 )?;
2012 Ok(())
2013 }
2014 }
2015
2016 impl fidl::encoding::ValueTypeMarker for CentralConnectPeripheralResponse {
2017 type Borrowed<'a> = &'a Self;
2018 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2019 value
2020 }
2021 }
2022
2023 unsafe impl fidl::encoding::TypeMarker for CentralConnectPeripheralResponse {
2024 type Owned = Self;
2025
2026 #[inline(always)]
2027 fn inline_align(_context: fidl::encoding::Context) -> usize {
2028 8
2029 }
2030
2031 #[inline(always)]
2032 fn inline_size(_context: fidl::encoding::Context) -> usize {
2033 8
2034 }
2035 }
2036
2037 unsafe impl<D: fidl::encoding::ResourceDialect>
2038 fidl::encoding::Encode<CentralConnectPeripheralResponse, D>
2039 for &CentralConnectPeripheralResponse
2040 {
2041 #[inline]
2042 unsafe fn encode(
2043 self,
2044 encoder: &mut fidl::encoding::Encoder<'_, D>,
2045 offset: usize,
2046 _depth: fidl::encoding::Depth,
2047 ) -> fidl::Result<()> {
2048 encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2049 fidl::encoding::Encode::<CentralConnectPeripheralResponse, D>::encode(
2051 (
2052 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2053 ),
2054 encoder, offset, _depth
2055 )
2056 }
2057 }
2058 unsafe impl<
2059 D: fidl::encoding::ResourceDialect,
2060 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2061 > fidl::encoding::Encode<CentralConnectPeripheralResponse, D> for (T0,)
2062 {
2063 #[inline]
2064 unsafe fn encode(
2065 self,
2066 encoder: &mut fidl::encoding::Encoder<'_, D>,
2067 offset: usize,
2068 depth: fidl::encoding::Depth,
2069 ) -> fidl::Result<()> {
2070 encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2071 self.0.encode(encoder, offset + 0, depth)?;
2075 Ok(())
2076 }
2077 }
2078
2079 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2080 for CentralConnectPeripheralResponse
2081 {
2082 #[inline(always)]
2083 fn new_empty() -> Self {
2084 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2085 }
2086
2087 #[inline]
2088 unsafe fn decode(
2089 &mut self,
2090 decoder: &mut fidl::encoding::Decoder<'_, D>,
2091 offset: usize,
2092 _depth: fidl::encoding::Depth,
2093 ) -> fidl::Result<()> {
2094 decoder.debug_check_bounds::<Self>(offset);
2095 fidl::decode!(
2097 fidl_fuchsia_bluetooth__common::Status,
2098 D,
2099 &mut self.status,
2100 decoder,
2101 offset + 0,
2102 _depth
2103 )?;
2104 Ok(())
2105 }
2106 }
2107
2108 impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralRequest {
2109 type Borrowed<'a> = &'a Self;
2110 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2111 value
2112 }
2113 }
2114
2115 unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralRequest {
2116 type Owned = Self;
2117
2118 #[inline(always)]
2119 fn inline_align(_context: fidl::encoding::Context) -> usize {
2120 8
2121 }
2122
2123 #[inline(always)]
2124 fn inline_size(_context: fidl::encoding::Context) -> usize {
2125 16
2126 }
2127 }
2128
2129 unsafe impl<D: fidl::encoding::ResourceDialect>
2130 fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D>
2131 for &CentralDisconnectPeripheralRequest
2132 {
2133 #[inline]
2134 unsafe fn encode(
2135 self,
2136 encoder: &mut fidl::encoding::Encoder<'_, D>,
2137 offset: usize,
2138 _depth: fidl::encoding::Depth,
2139 ) -> fidl::Result<()> {
2140 encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2141 fidl::encoding::Encode::<CentralDisconnectPeripheralRequest, D>::encode(
2143 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2144 &self.identifier,
2145 ),),
2146 encoder,
2147 offset,
2148 _depth,
2149 )
2150 }
2151 }
2152 unsafe impl<
2153 D: fidl::encoding::ResourceDialect,
2154 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2155 > fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D> for (T0,)
2156 {
2157 #[inline]
2158 unsafe fn encode(
2159 self,
2160 encoder: &mut fidl::encoding::Encoder<'_, D>,
2161 offset: usize,
2162 depth: fidl::encoding::Depth,
2163 ) -> fidl::Result<()> {
2164 encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2165 self.0.encode(encoder, offset + 0, depth)?;
2169 Ok(())
2170 }
2171 }
2172
2173 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2174 for CentralDisconnectPeripheralRequest
2175 {
2176 #[inline(always)]
2177 fn new_empty() -> Self {
2178 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2179 }
2180
2181 #[inline]
2182 unsafe fn decode(
2183 &mut self,
2184 decoder: &mut fidl::encoding::Decoder<'_, D>,
2185 offset: usize,
2186 _depth: fidl::encoding::Depth,
2187 ) -> fidl::Result<()> {
2188 decoder.debug_check_bounds::<Self>(offset);
2189 fidl::decode!(
2191 fidl::encoding::BoundedString<16>,
2192 D,
2193 &mut self.identifier,
2194 decoder,
2195 offset + 0,
2196 _depth
2197 )?;
2198 Ok(())
2199 }
2200 }
2201
2202 impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralResponse {
2203 type Borrowed<'a> = &'a Self;
2204 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2205 value
2206 }
2207 }
2208
2209 unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralResponse {
2210 type Owned = Self;
2211
2212 #[inline(always)]
2213 fn inline_align(_context: fidl::encoding::Context) -> usize {
2214 8
2215 }
2216
2217 #[inline(always)]
2218 fn inline_size(_context: fidl::encoding::Context) -> usize {
2219 8
2220 }
2221 }
2222
2223 unsafe impl<D: fidl::encoding::ResourceDialect>
2224 fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D>
2225 for &CentralDisconnectPeripheralResponse
2226 {
2227 #[inline]
2228 unsafe fn encode(
2229 self,
2230 encoder: &mut fidl::encoding::Encoder<'_, D>,
2231 offset: usize,
2232 _depth: fidl::encoding::Depth,
2233 ) -> fidl::Result<()> {
2234 encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2235 fidl::encoding::Encode::<CentralDisconnectPeripheralResponse, D>::encode(
2237 (
2238 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2239 ),
2240 encoder, offset, _depth
2241 )
2242 }
2243 }
2244 unsafe impl<
2245 D: fidl::encoding::ResourceDialect,
2246 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2247 > fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D> for (T0,)
2248 {
2249 #[inline]
2250 unsafe fn encode(
2251 self,
2252 encoder: &mut fidl::encoding::Encoder<'_, D>,
2253 offset: usize,
2254 depth: fidl::encoding::Depth,
2255 ) -> fidl::Result<()> {
2256 encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2257 self.0.encode(encoder, offset + 0, depth)?;
2261 Ok(())
2262 }
2263 }
2264
2265 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2266 for CentralDisconnectPeripheralResponse
2267 {
2268 #[inline(always)]
2269 fn new_empty() -> Self {
2270 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2271 }
2272
2273 #[inline]
2274 unsafe fn decode(
2275 &mut self,
2276 decoder: &mut fidl::encoding::Decoder<'_, D>,
2277 offset: usize,
2278 _depth: fidl::encoding::Depth,
2279 ) -> fidl::Result<()> {
2280 decoder.debug_check_bounds::<Self>(offset);
2281 fidl::decode!(
2283 fidl_fuchsia_bluetooth__common::Status,
2284 D,
2285 &mut self.status,
2286 decoder,
2287 offset + 0,
2288 _depth
2289 )?;
2290 Ok(())
2291 }
2292 }
2293
2294 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralRequest {
2295 type Borrowed<'a> = &'a Self;
2296 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2297 value
2298 }
2299 }
2300
2301 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralRequest {
2302 type Owned = Self;
2303
2304 #[inline(always)]
2305 fn inline_align(_context: fidl::encoding::Context) -> usize {
2306 8
2307 }
2308
2309 #[inline(always)]
2310 fn inline_size(_context: fidl::encoding::Context) -> usize {
2311 16
2312 }
2313 }
2314
2315 unsafe impl<D: fidl::encoding::ResourceDialect>
2316 fidl::encoding::Encode<CentralGetPeripheralRequest, D> for &CentralGetPeripheralRequest
2317 {
2318 #[inline]
2319 unsafe fn encode(
2320 self,
2321 encoder: &mut fidl::encoding::Encoder<'_, D>,
2322 offset: usize,
2323 _depth: fidl::encoding::Depth,
2324 ) -> fidl::Result<()> {
2325 encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2326 fidl::encoding::Encode::<CentralGetPeripheralRequest, D>::encode(
2328 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2329 &self.identifier,
2330 ),),
2331 encoder,
2332 offset,
2333 _depth,
2334 )
2335 }
2336 }
2337 unsafe impl<
2338 D: fidl::encoding::ResourceDialect,
2339 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2340 > fidl::encoding::Encode<CentralGetPeripheralRequest, D> for (T0,)
2341 {
2342 #[inline]
2343 unsafe fn encode(
2344 self,
2345 encoder: &mut fidl::encoding::Encoder<'_, D>,
2346 offset: usize,
2347 depth: fidl::encoding::Depth,
2348 ) -> fidl::Result<()> {
2349 encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2350 self.0.encode(encoder, offset + 0, depth)?;
2354 Ok(())
2355 }
2356 }
2357
2358 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2359 for CentralGetPeripheralRequest
2360 {
2361 #[inline(always)]
2362 fn new_empty() -> Self {
2363 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2364 }
2365
2366 #[inline]
2367 unsafe fn decode(
2368 &mut self,
2369 decoder: &mut fidl::encoding::Decoder<'_, D>,
2370 offset: usize,
2371 _depth: fidl::encoding::Depth,
2372 ) -> fidl::Result<()> {
2373 decoder.debug_check_bounds::<Self>(offset);
2374 fidl::decode!(
2376 fidl::encoding::BoundedString<16>,
2377 D,
2378 &mut self.identifier,
2379 decoder,
2380 offset + 0,
2381 _depth
2382 )?;
2383 Ok(())
2384 }
2385 }
2386
2387 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralResponse {
2388 type Borrowed<'a> = &'a Self;
2389 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2390 value
2391 }
2392 }
2393
2394 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralResponse {
2395 type Owned = Self;
2396
2397 #[inline(always)]
2398 fn inline_align(_context: fidl::encoding::Context) -> usize {
2399 8
2400 }
2401
2402 #[inline(always)]
2403 fn inline_size(_context: fidl::encoding::Context) -> usize {
2404 8
2405 }
2406 }
2407
2408 unsafe impl<D: fidl::encoding::ResourceDialect>
2409 fidl::encoding::Encode<CentralGetPeripheralResponse, D> for &CentralGetPeripheralResponse
2410 {
2411 #[inline]
2412 unsafe fn encode(
2413 self,
2414 encoder: &mut fidl::encoding::Encoder<'_, D>,
2415 offset: usize,
2416 _depth: fidl::encoding::Depth,
2417 ) -> fidl::Result<()> {
2418 encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2419 fidl::encoding::Encode::<CentralGetPeripheralResponse, D>::encode(
2421 (<fidl::encoding::Boxed<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(
2422 &self.peripheral,
2423 ),),
2424 encoder,
2425 offset,
2426 _depth,
2427 )
2428 }
2429 }
2430 unsafe impl<
2431 D: fidl::encoding::ResourceDialect,
2432 T0: fidl::encoding::Encode<fidl::encoding::Boxed<RemoteDevice>, D>,
2433 > fidl::encoding::Encode<CentralGetPeripheralResponse, D> for (T0,)
2434 {
2435 #[inline]
2436 unsafe fn encode(
2437 self,
2438 encoder: &mut fidl::encoding::Encoder<'_, D>,
2439 offset: usize,
2440 depth: fidl::encoding::Depth,
2441 ) -> fidl::Result<()> {
2442 encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2443 self.0.encode(encoder, offset + 0, depth)?;
2447 Ok(())
2448 }
2449 }
2450
2451 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2452 for CentralGetPeripheralResponse
2453 {
2454 #[inline(always)]
2455 fn new_empty() -> Self {
2456 Self { peripheral: fidl::new_empty!(fidl::encoding::Boxed<RemoteDevice>, D) }
2457 }
2458
2459 #[inline]
2460 unsafe fn decode(
2461 &mut self,
2462 decoder: &mut fidl::encoding::Decoder<'_, D>,
2463 offset: usize,
2464 _depth: fidl::encoding::Depth,
2465 ) -> fidl::Result<()> {
2466 decoder.debug_check_bounds::<Self>(offset);
2467 fidl::decode!(
2469 fidl::encoding::Boxed<RemoteDevice>,
2470 D,
2471 &mut self.peripheral,
2472 decoder,
2473 offset + 0,
2474 _depth
2475 )?;
2476 Ok(())
2477 }
2478 }
2479
2480 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsRequest {
2481 type Borrowed<'a> = &'a Self;
2482 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2483 value
2484 }
2485 }
2486
2487 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsRequest {
2488 type Owned = Self;
2489
2490 #[inline(always)]
2491 fn inline_align(_context: fidl::encoding::Context) -> usize {
2492 8
2493 }
2494
2495 #[inline(always)]
2496 fn inline_size(_context: fidl::encoding::Context) -> usize {
2497 16
2498 }
2499 }
2500
2501 unsafe impl<D: fidl::encoding::ResourceDialect>
2502 fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for &CentralGetPeripheralsRequest
2503 {
2504 #[inline]
2505 unsafe fn encode(
2506 self,
2507 encoder: &mut fidl::encoding::Encoder<'_, D>,
2508 offset: usize,
2509 _depth: fidl::encoding::Depth,
2510 ) -> fidl::Result<()> {
2511 encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2512 fidl::encoding::Encode::<CentralGetPeripheralsRequest, D>::encode(
2514 (<fidl::encoding::Optional<
2515 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2516 > as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),),
2517 encoder,
2518 offset,
2519 _depth,
2520 )
2521 }
2522 }
2523 unsafe impl<
2524 D: fidl::encoding::ResourceDialect,
2525 T0: fidl::encoding::Encode<
2526 fidl::encoding::Optional<
2527 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2528 >,
2529 D,
2530 >,
2531 > fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for (T0,)
2532 {
2533 #[inline]
2534 unsafe fn encode(
2535 self,
2536 encoder: &mut fidl::encoding::Encoder<'_, D>,
2537 offset: usize,
2538 depth: fidl::encoding::Depth,
2539 ) -> fidl::Result<()> {
2540 encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2541 self.0.encode(encoder, offset + 0, depth)?;
2545 Ok(())
2546 }
2547 }
2548
2549 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2550 for CentralGetPeripheralsRequest
2551 {
2552 #[inline(always)]
2553 fn new_empty() -> Self {
2554 Self {
2555 service_uuids: fidl::new_empty!(
2556 fidl::encoding::Optional<
2557 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2558 >,
2559 D
2560 ),
2561 }
2562 }
2563
2564 #[inline]
2565 unsafe fn decode(
2566 &mut self,
2567 decoder: &mut fidl::encoding::Decoder<'_, D>,
2568 offset: usize,
2569 _depth: fidl::encoding::Depth,
2570 ) -> fidl::Result<()> {
2571 decoder.debug_check_bounds::<Self>(offset);
2572 fidl::decode!(
2574 fidl::encoding::Optional<
2575 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2576 >,
2577 D,
2578 &mut self.service_uuids,
2579 decoder,
2580 offset + 0,
2581 _depth
2582 )?;
2583 Ok(())
2584 }
2585 }
2586
2587 impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsResponse {
2588 type Borrowed<'a> = &'a Self;
2589 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2590 value
2591 }
2592 }
2593
2594 unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsResponse {
2595 type Owned = Self;
2596
2597 #[inline(always)]
2598 fn inline_align(_context: fidl::encoding::Context) -> usize {
2599 8
2600 }
2601
2602 #[inline(always)]
2603 fn inline_size(_context: fidl::encoding::Context) -> usize {
2604 16
2605 }
2606 }
2607
2608 unsafe impl<D: fidl::encoding::ResourceDialect>
2609 fidl::encoding::Encode<CentralGetPeripheralsResponse, D>
2610 for &CentralGetPeripheralsResponse
2611 {
2612 #[inline]
2613 unsafe fn encode(
2614 self,
2615 encoder: &mut fidl::encoding::Encoder<'_, D>,
2616 offset: usize,
2617 _depth: fidl::encoding::Depth,
2618 ) -> fidl::Result<()> {
2619 encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2620 fidl::encoding::Encode::<CentralGetPeripheralsResponse, D>::encode(
2622 (
2623 <fidl::encoding::UnboundedVector<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(&self.peripherals),
2624 ),
2625 encoder, offset, _depth
2626 )
2627 }
2628 }
2629 unsafe impl<
2630 D: fidl::encoding::ResourceDialect,
2631 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RemoteDevice>, D>,
2632 > fidl::encoding::Encode<CentralGetPeripheralsResponse, D> for (T0,)
2633 {
2634 #[inline]
2635 unsafe fn encode(
2636 self,
2637 encoder: &mut fidl::encoding::Encoder<'_, D>,
2638 offset: usize,
2639 depth: fidl::encoding::Depth,
2640 ) -> fidl::Result<()> {
2641 encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2642 self.0.encode(encoder, offset + 0, depth)?;
2646 Ok(())
2647 }
2648 }
2649
2650 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2651 for CentralGetPeripheralsResponse
2652 {
2653 #[inline(always)]
2654 fn new_empty() -> Self {
2655 Self { peripherals: fidl::new_empty!(fidl::encoding::UnboundedVector<RemoteDevice>, D) }
2656 }
2657
2658 #[inline]
2659 unsafe fn decode(
2660 &mut self,
2661 decoder: &mut fidl::encoding::Decoder<'_, D>,
2662 offset: usize,
2663 _depth: fidl::encoding::Depth,
2664 ) -> fidl::Result<()> {
2665 decoder.debug_check_bounds::<Self>(offset);
2666 fidl::decode!(
2668 fidl::encoding::UnboundedVector<RemoteDevice>,
2669 D,
2670 &mut self.peripherals,
2671 decoder,
2672 offset + 0,
2673 _depth
2674 )?;
2675 Ok(())
2676 }
2677 }
2678
2679 impl fidl::encoding::ValueTypeMarker for CentralOnDeviceDiscoveredRequest {
2680 type Borrowed<'a> = &'a Self;
2681 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2682 value
2683 }
2684 }
2685
2686 unsafe impl fidl::encoding::TypeMarker for CentralOnDeviceDiscoveredRequest {
2687 type Owned = Self;
2688
2689 #[inline(always)]
2690 fn inline_align(_context: fidl::encoding::Context) -> usize {
2691 8
2692 }
2693
2694 #[inline(always)]
2695 fn inline_size(_context: fidl::encoding::Context) -> usize {
2696 40
2697 }
2698 }
2699
2700 unsafe impl<D: fidl::encoding::ResourceDialect>
2701 fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D>
2702 for &CentralOnDeviceDiscoveredRequest
2703 {
2704 #[inline]
2705 unsafe fn encode(
2706 self,
2707 encoder: &mut fidl::encoding::Encoder<'_, D>,
2708 offset: usize,
2709 _depth: fidl::encoding::Depth,
2710 ) -> fidl::Result<()> {
2711 encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2712 fidl::encoding::Encode::<CentralOnDeviceDiscoveredRequest, D>::encode(
2714 (<RemoteDevice as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
2715 encoder,
2716 offset,
2717 _depth,
2718 )
2719 }
2720 }
2721 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RemoteDevice, D>>
2722 fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D> for (T0,)
2723 {
2724 #[inline]
2725 unsafe fn encode(
2726 self,
2727 encoder: &mut fidl::encoding::Encoder<'_, D>,
2728 offset: usize,
2729 depth: fidl::encoding::Depth,
2730 ) -> fidl::Result<()> {
2731 encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2732 self.0.encode(encoder, offset + 0, depth)?;
2736 Ok(())
2737 }
2738 }
2739
2740 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2741 for CentralOnDeviceDiscoveredRequest
2742 {
2743 #[inline(always)]
2744 fn new_empty() -> Self {
2745 Self { device: fidl::new_empty!(RemoteDevice, D) }
2746 }
2747
2748 #[inline]
2749 unsafe fn decode(
2750 &mut self,
2751 decoder: &mut fidl::encoding::Decoder<'_, D>,
2752 offset: usize,
2753 _depth: fidl::encoding::Depth,
2754 ) -> fidl::Result<()> {
2755 decoder.debug_check_bounds::<Self>(offset);
2756 fidl::decode!(RemoteDevice, D, &mut self.device, decoder, offset + 0, _depth)?;
2758 Ok(())
2759 }
2760 }
2761
2762 impl fidl::encoding::ValueTypeMarker for CentralOnPeripheralDisconnectedRequest {
2763 type Borrowed<'a> = &'a Self;
2764 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2765 value
2766 }
2767 }
2768
2769 unsafe impl fidl::encoding::TypeMarker for CentralOnPeripheralDisconnectedRequest {
2770 type Owned = Self;
2771
2772 #[inline(always)]
2773 fn inline_align(_context: fidl::encoding::Context) -> usize {
2774 8
2775 }
2776
2777 #[inline(always)]
2778 fn inline_size(_context: fidl::encoding::Context) -> usize {
2779 16
2780 }
2781 }
2782
2783 unsafe impl<D: fidl::encoding::ResourceDialect>
2784 fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D>
2785 for &CentralOnPeripheralDisconnectedRequest
2786 {
2787 #[inline]
2788 unsafe fn encode(
2789 self,
2790 encoder: &mut fidl::encoding::Encoder<'_, D>,
2791 offset: usize,
2792 _depth: fidl::encoding::Depth,
2793 ) -> fidl::Result<()> {
2794 encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2795 fidl::encoding::Encode::<CentralOnPeripheralDisconnectedRequest, D>::encode(
2797 (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2798 &self.identifier,
2799 ),),
2800 encoder,
2801 offset,
2802 _depth,
2803 )
2804 }
2805 }
2806 unsafe impl<
2807 D: fidl::encoding::ResourceDialect,
2808 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2809 > fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D> for (T0,)
2810 {
2811 #[inline]
2812 unsafe fn encode(
2813 self,
2814 encoder: &mut fidl::encoding::Encoder<'_, D>,
2815 offset: usize,
2816 depth: fidl::encoding::Depth,
2817 ) -> fidl::Result<()> {
2818 encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2819 self.0.encode(encoder, offset + 0, depth)?;
2823 Ok(())
2824 }
2825 }
2826
2827 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2828 for CentralOnPeripheralDisconnectedRequest
2829 {
2830 #[inline(always)]
2831 fn new_empty() -> Self {
2832 Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2833 }
2834
2835 #[inline]
2836 unsafe fn decode(
2837 &mut self,
2838 decoder: &mut fidl::encoding::Decoder<'_, D>,
2839 offset: usize,
2840 _depth: fidl::encoding::Depth,
2841 ) -> fidl::Result<()> {
2842 decoder.debug_check_bounds::<Self>(offset);
2843 fidl::decode!(
2845 fidl::encoding::BoundedString<16>,
2846 D,
2847 &mut self.identifier,
2848 decoder,
2849 offset + 0,
2850 _depth
2851 )?;
2852 Ok(())
2853 }
2854 }
2855
2856 impl fidl::encoding::ValueTypeMarker for CentralOnScanStateChangedRequest {
2857 type Borrowed<'a> = &'a Self;
2858 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2859 value
2860 }
2861 }
2862
2863 unsafe impl fidl::encoding::TypeMarker for CentralOnScanStateChangedRequest {
2864 type Owned = Self;
2865
2866 #[inline(always)]
2867 fn inline_align(_context: fidl::encoding::Context) -> usize {
2868 1
2869 }
2870
2871 #[inline(always)]
2872 fn inline_size(_context: fidl::encoding::Context) -> usize {
2873 1
2874 }
2875 }
2876
2877 unsafe impl<D: fidl::encoding::ResourceDialect>
2878 fidl::encoding::Encode<CentralOnScanStateChangedRequest, D>
2879 for &CentralOnScanStateChangedRequest
2880 {
2881 #[inline]
2882 unsafe fn encode(
2883 self,
2884 encoder: &mut fidl::encoding::Encoder<'_, D>,
2885 offset: usize,
2886 _depth: fidl::encoding::Depth,
2887 ) -> fidl::Result<()> {
2888 encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2889 fidl::encoding::Encode::<CentralOnScanStateChangedRequest, D>::encode(
2891 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.scanning),),
2892 encoder,
2893 offset,
2894 _depth,
2895 )
2896 }
2897 }
2898 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2899 fidl::encoding::Encode<CentralOnScanStateChangedRequest, D> for (T0,)
2900 {
2901 #[inline]
2902 unsafe fn encode(
2903 self,
2904 encoder: &mut fidl::encoding::Encoder<'_, D>,
2905 offset: usize,
2906 depth: fidl::encoding::Depth,
2907 ) -> fidl::Result<()> {
2908 encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2909 self.0.encode(encoder, offset + 0, depth)?;
2913 Ok(())
2914 }
2915 }
2916
2917 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2918 for CentralOnScanStateChangedRequest
2919 {
2920 #[inline(always)]
2921 fn new_empty() -> Self {
2922 Self { scanning: fidl::new_empty!(bool, D) }
2923 }
2924
2925 #[inline]
2926 unsafe fn decode(
2927 &mut self,
2928 decoder: &mut fidl::encoding::Decoder<'_, D>,
2929 offset: usize,
2930 _depth: fidl::encoding::Depth,
2931 ) -> fidl::Result<()> {
2932 decoder.debug_check_bounds::<Self>(offset);
2933 fidl::decode!(bool, D, &mut self.scanning, decoder, offset + 0, _depth)?;
2935 Ok(())
2936 }
2937 }
2938
2939 impl fidl::encoding::ValueTypeMarker for CentralStartScanRequest {
2940 type Borrowed<'a> = &'a Self;
2941 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2942 value
2943 }
2944 }
2945
2946 unsafe impl fidl::encoding::TypeMarker for CentralStartScanRequest {
2947 type Owned = Self;
2948
2949 #[inline(always)]
2950 fn inline_align(_context: fidl::encoding::Context) -> usize {
2951 8
2952 }
2953
2954 #[inline(always)]
2955 fn inline_size(_context: fidl::encoding::Context) -> usize {
2956 8
2957 }
2958 }
2959
2960 unsafe impl<D: fidl::encoding::ResourceDialect>
2961 fidl::encoding::Encode<CentralStartScanRequest, D> for &CentralStartScanRequest
2962 {
2963 #[inline]
2964 unsafe fn encode(
2965 self,
2966 encoder: &mut fidl::encoding::Encoder<'_, D>,
2967 offset: usize,
2968 _depth: fidl::encoding::Depth,
2969 ) -> fidl::Result<()> {
2970 encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2971 fidl::encoding::Encode::<CentralStartScanRequest, D>::encode(
2973 (<fidl::encoding::Boxed<ScanFilter> as fidl::encoding::ValueTypeMarker>::borrow(
2974 &self.filter,
2975 ),),
2976 encoder,
2977 offset,
2978 _depth,
2979 )
2980 }
2981 }
2982 unsafe impl<
2983 D: fidl::encoding::ResourceDialect,
2984 T0: fidl::encoding::Encode<fidl::encoding::Boxed<ScanFilter>, D>,
2985 > fidl::encoding::Encode<CentralStartScanRequest, D> for (T0,)
2986 {
2987 #[inline]
2988 unsafe fn encode(
2989 self,
2990 encoder: &mut fidl::encoding::Encoder<'_, D>,
2991 offset: usize,
2992 depth: fidl::encoding::Depth,
2993 ) -> fidl::Result<()> {
2994 encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2995 self.0.encode(encoder, offset + 0, depth)?;
2999 Ok(())
3000 }
3001 }
3002
3003 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3004 for CentralStartScanRequest
3005 {
3006 #[inline(always)]
3007 fn new_empty() -> Self {
3008 Self { filter: fidl::new_empty!(fidl::encoding::Boxed<ScanFilter>, D) }
3009 }
3010
3011 #[inline]
3012 unsafe fn decode(
3013 &mut self,
3014 decoder: &mut fidl::encoding::Decoder<'_, D>,
3015 offset: usize,
3016 _depth: fidl::encoding::Depth,
3017 ) -> fidl::Result<()> {
3018 decoder.debug_check_bounds::<Self>(offset);
3019 fidl::decode!(
3021 fidl::encoding::Boxed<ScanFilter>,
3022 D,
3023 &mut self.filter,
3024 decoder,
3025 offset + 0,
3026 _depth
3027 )?;
3028 Ok(())
3029 }
3030 }
3031
3032 impl fidl::encoding::ValueTypeMarker for CentralStartScanResponse {
3033 type Borrowed<'a> = &'a Self;
3034 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3035 value
3036 }
3037 }
3038
3039 unsafe impl fidl::encoding::TypeMarker for CentralStartScanResponse {
3040 type Owned = Self;
3041
3042 #[inline(always)]
3043 fn inline_align(_context: fidl::encoding::Context) -> usize {
3044 8
3045 }
3046
3047 #[inline(always)]
3048 fn inline_size(_context: fidl::encoding::Context) -> usize {
3049 8
3050 }
3051 }
3052
3053 unsafe impl<D: fidl::encoding::ResourceDialect>
3054 fidl::encoding::Encode<CentralStartScanResponse, D> for &CentralStartScanResponse
3055 {
3056 #[inline]
3057 unsafe fn encode(
3058 self,
3059 encoder: &mut fidl::encoding::Encoder<'_, D>,
3060 offset: usize,
3061 _depth: fidl::encoding::Depth,
3062 ) -> fidl::Result<()> {
3063 encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3064 fidl::encoding::Encode::<CentralStartScanResponse, D>::encode(
3066 (
3067 <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
3068 ),
3069 encoder, offset, _depth
3070 )
3071 }
3072 }
3073 unsafe impl<
3074 D: fidl::encoding::ResourceDialect,
3075 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
3076 > fidl::encoding::Encode<CentralStartScanResponse, D> for (T0,)
3077 {
3078 #[inline]
3079 unsafe fn encode(
3080 self,
3081 encoder: &mut fidl::encoding::Encoder<'_, D>,
3082 offset: usize,
3083 depth: fidl::encoding::Depth,
3084 ) -> fidl::Result<()> {
3085 encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3086 self.0.encode(encoder, offset + 0, depth)?;
3090 Ok(())
3091 }
3092 }
3093
3094 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3095 for CentralStartScanResponse
3096 {
3097 #[inline(always)]
3098 fn new_empty() -> Self {
3099 Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
3100 }
3101
3102 #[inline]
3103 unsafe fn decode(
3104 &mut self,
3105 decoder: &mut fidl::encoding::Decoder<'_, D>,
3106 offset: usize,
3107 _depth: fidl::encoding::Depth,
3108 ) -> fidl::Result<()> {
3109 decoder.debug_check_bounds::<Self>(offset);
3110 fidl::decode!(
3112 fidl_fuchsia_bluetooth__common::Status,
3113 D,
3114 &mut self.status,
3115 decoder,
3116 offset + 0,
3117 _depth
3118 )?;
3119 Ok(())
3120 }
3121 }
3122
3123 impl fidl::encoding::ValueTypeMarker for ManufacturerData {
3124 type Borrowed<'a> = &'a Self;
3125 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3126 value
3127 }
3128 }
3129
3130 unsafe impl fidl::encoding::TypeMarker for ManufacturerData {
3131 type Owned = Self;
3132
3133 #[inline(always)]
3134 fn inline_align(_context: fidl::encoding::Context) -> usize {
3135 8
3136 }
3137
3138 #[inline(always)]
3139 fn inline_size(_context: fidl::encoding::Context) -> usize {
3140 24
3141 }
3142 }
3143
3144 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManufacturerData, D>
3145 for &ManufacturerData
3146 {
3147 #[inline]
3148 unsafe fn encode(
3149 self,
3150 encoder: &mut fidl::encoding::Encoder<'_, D>,
3151 offset: usize,
3152 _depth: fidl::encoding::Depth,
3153 ) -> fidl::Result<()> {
3154 encoder.debug_check_bounds::<ManufacturerData>(offset);
3155 fidl::encoding::Encode::<ManufacturerData, D>::encode(
3157 (
3158 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3159 <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(
3160 &self.data,
3161 ),
3162 ),
3163 encoder,
3164 offset,
3165 _depth,
3166 )
3167 }
3168 }
3169 unsafe impl<
3170 D: fidl::encoding::ResourceDialect,
3171 T0: fidl::encoding::Encode<u16, D>,
3172 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3173 > fidl::encoding::Encode<ManufacturerData, D> for (T0, T1)
3174 {
3175 #[inline]
3176 unsafe fn encode(
3177 self,
3178 encoder: &mut fidl::encoding::Encoder<'_, D>,
3179 offset: usize,
3180 depth: fidl::encoding::Depth,
3181 ) -> fidl::Result<()> {
3182 encoder.debug_check_bounds::<ManufacturerData>(offset);
3183 unsafe {
3186 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3187 (ptr as *mut u64).write_unaligned(0);
3188 }
3189 self.0.encode(encoder, offset + 0, depth)?;
3191 self.1.encode(encoder, offset + 8, depth)?;
3192 Ok(())
3193 }
3194 }
3195
3196 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManufacturerData {
3197 #[inline(always)]
3198 fn new_empty() -> Self {
3199 Self {
3200 company_id: fidl::new_empty!(u16, D),
3201 data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3202 }
3203 }
3204
3205 #[inline]
3206 unsafe fn decode(
3207 &mut self,
3208 decoder: &mut fidl::encoding::Decoder<'_, D>,
3209 offset: usize,
3210 _depth: fidl::encoding::Depth,
3211 ) -> fidl::Result<()> {
3212 decoder.debug_check_bounds::<Self>(offset);
3213 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3215 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3216 let mask = 0xffffffffffff0000u64;
3217 let maskedval = padval & mask;
3218 if maskedval != 0 {
3219 return Err(fidl::Error::NonZeroPadding {
3220 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3221 });
3222 }
3223 fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3224 fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 8, _depth)?;
3225 Ok(())
3226 }
3227 }
3228
3229 impl fidl::encoding::ValueTypeMarker for ManufacturerSpecificDataEntry {
3230 type Borrowed<'a> = &'a Self;
3231 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3232 value
3233 }
3234 }
3235
3236 unsafe impl fidl::encoding::TypeMarker for ManufacturerSpecificDataEntry {
3237 type Owned = Self;
3238
3239 #[inline(always)]
3240 fn inline_align(_context: fidl::encoding::Context) -> usize {
3241 8
3242 }
3243
3244 #[inline(always)]
3245 fn inline_size(_context: fidl::encoding::Context) -> usize {
3246 24
3247 }
3248 }
3249
3250 unsafe impl<D: fidl::encoding::ResourceDialect>
3251 fidl::encoding::Encode<ManufacturerSpecificDataEntry, D>
3252 for &ManufacturerSpecificDataEntry
3253 {
3254 #[inline]
3255 unsafe fn encode(
3256 self,
3257 encoder: &mut fidl::encoding::Encoder<'_, D>,
3258 offset: usize,
3259 _depth: fidl::encoding::Depth,
3260 ) -> fidl::Result<()> {
3261 encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3262 fidl::encoding::Encode::<ManufacturerSpecificDataEntry, D>::encode(
3264 (
3265 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3266 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3267 ),
3268 encoder, offset, _depth
3269 )
3270 }
3271 }
3272 unsafe impl<
3273 D: fidl::encoding::ResourceDialect,
3274 T0: fidl::encoding::Encode<u16, D>,
3275 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3276 > fidl::encoding::Encode<ManufacturerSpecificDataEntry, D> for (T0, T1)
3277 {
3278 #[inline]
3279 unsafe fn encode(
3280 self,
3281 encoder: &mut fidl::encoding::Encoder<'_, D>,
3282 offset: usize,
3283 depth: fidl::encoding::Depth,
3284 ) -> fidl::Result<()> {
3285 encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3286 unsafe {
3289 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3290 (ptr as *mut u64).write_unaligned(0);
3291 }
3292 self.0.encode(encoder, offset + 0, depth)?;
3294 self.1.encode(encoder, offset + 8, depth)?;
3295 Ok(())
3296 }
3297 }
3298
3299 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3300 for ManufacturerSpecificDataEntry
3301 {
3302 #[inline(always)]
3303 fn new_empty() -> Self {
3304 Self {
3305 company_id: fidl::new_empty!(u16, D),
3306 data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3307 }
3308 }
3309
3310 #[inline]
3311 unsafe fn decode(
3312 &mut self,
3313 decoder: &mut fidl::encoding::Decoder<'_, D>,
3314 offset: usize,
3315 _depth: fidl::encoding::Depth,
3316 ) -> fidl::Result<()> {
3317 decoder.debug_check_bounds::<Self>(offset);
3318 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3320 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3321 let mask = 0xffffffffffff0000u64;
3322 let maskedval = padval & mask;
3323 if maskedval != 0 {
3324 return Err(fidl::Error::NonZeroPadding {
3325 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3326 });
3327 }
3328 fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3329 fidl::decode!(
3330 fidl::encoding::UnboundedVector<u8>,
3331 D,
3332 &mut self.data,
3333 decoder,
3334 offset + 8,
3335 _depth
3336 )?;
3337 Ok(())
3338 }
3339 }
3340
3341 impl fidl::encoding::ValueTypeMarker for RemoteDevice {
3342 type Borrowed<'a> = &'a Self;
3343 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3344 value
3345 }
3346 }
3347
3348 unsafe impl fidl::encoding::TypeMarker for RemoteDevice {
3349 type Owned = Self;
3350
3351 #[inline(always)]
3352 fn inline_align(_context: fidl::encoding::Context) -> usize {
3353 8
3354 }
3355
3356 #[inline(always)]
3357 fn inline_size(_context: fidl::encoding::Context) -> usize {
3358 40
3359 }
3360 }
3361
3362 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RemoteDevice, D>
3363 for &RemoteDevice
3364 {
3365 #[inline]
3366 unsafe fn encode(
3367 self,
3368 encoder: &mut fidl::encoding::Encoder<'_, D>,
3369 offset: usize,
3370 _depth: fidl::encoding::Depth,
3371 ) -> fidl::Result<()> {
3372 encoder.debug_check_bounds::<RemoteDevice>(offset);
3373 fidl::encoding::Encode::<RemoteDevice, D>::encode(
3375 (
3376 <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(&self.identifier),
3377 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3378 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi),
3379 <fidl::encoding::Boxed<AdvertisingDataDeprecated> as fidl::encoding::ValueTypeMarker>::borrow(&self.advertising_data),
3380 ),
3381 encoder, offset, _depth
3382 )
3383 }
3384 }
3385 unsafe impl<
3386 D: fidl::encoding::ResourceDialect,
3387 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
3388 T1: fidl::encoding::Encode<bool, D>,
3389 T2: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3390 T3: fidl::encoding::Encode<fidl::encoding::Boxed<AdvertisingDataDeprecated>, D>,
3391 > fidl::encoding::Encode<RemoteDevice, D> for (T0, T1, T2, T3)
3392 {
3393 #[inline]
3394 unsafe fn encode(
3395 self,
3396 encoder: &mut fidl::encoding::Encoder<'_, D>,
3397 offset: usize,
3398 depth: fidl::encoding::Depth,
3399 ) -> fidl::Result<()> {
3400 encoder.debug_check_bounds::<RemoteDevice>(offset);
3401 unsafe {
3404 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
3405 (ptr as *mut u64).write_unaligned(0);
3406 }
3407 self.0.encode(encoder, offset + 0, depth)?;
3409 self.1.encode(encoder, offset + 16, depth)?;
3410 self.2.encode(encoder, offset + 24, depth)?;
3411 self.3.encode(encoder, offset + 32, depth)?;
3412 Ok(())
3413 }
3414 }
3415
3416 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RemoteDevice {
3417 #[inline(always)]
3418 fn new_empty() -> Self {
3419 Self {
3420 identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D),
3421 connectable: fidl::new_empty!(bool, D),
3422 rssi: fidl::new_empty!(
3423 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3424 D
3425 ),
3426 advertising_data: fidl::new_empty!(
3427 fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3428 D
3429 ),
3430 }
3431 }
3432
3433 #[inline]
3434 unsafe fn decode(
3435 &mut self,
3436 decoder: &mut fidl::encoding::Decoder<'_, D>,
3437 offset: usize,
3438 _depth: fidl::encoding::Depth,
3439 ) -> fidl::Result<()> {
3440 decoder.debug_check_bounds::<Self>(offset);
3441 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
3443 let padval = unsafe { (ptr as *const u64).read_unaligned() };
3444 let mask = 0xffffffffffffff00u64;
3445 let maskedval = padval & mask;
3446 if maskedval != 0 {
3447 return Err(fidl::Error::NonZeroPadding {
3448 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
3449 });
3450 }
3451 fidl::decode!(
3452 fidl::encoding::BoundedString<16>,
3453 D,
3454 &mut self.identifier,
3455 decoder,
3456 offset + 0,
3457 _depth
3458 )?;
3459 fidl::decode!(bool, D, &mut self.connectable, decoder, offset + 16, _depth)?;
3460 fidl::decode!(
3461 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3462 D,
3463 &mut self.rssi,
3464 decoder,
3465 offset + 24,
3466 _depth
3467 )?;
3468 fidl::decode!(
3469 fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3470 D,
3471 &mut self.advertising_data,
3472 decoder,
3473 offset + 32,
3474 _depth
3475 )?;
3476 Ok(())
3477 }
3478 }
3479
3480 impl fidl::encoding::ValueTypeMarker for ScanFilter {
3481 type Borrowed<'a> = &'a Self;
3482 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3483 value
3484 }
3485 }
3486
3487 unsafe impl fidl::encoding::TypeMarker for ScanFilter {
3488 type Owned = Self;
3489
3490 #[inline(always)]
3491 fn inline_align(_context: fidl::encoding::Context) -> usize {
3492 8
3493 }
3494
3495 #[inline(always)]
3496 fn inline_size(_context: fidl::encoding::Context) -> usize {
3497 72
3498 }
3499 }
3500
3501 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanFilter, D>
3502 for &ScanFilter
3503 {
3504 #[inline]
3505 unsafe fn encode(
3506 self,
3507 encoder: &mut fidl::encoding::Encoder<'_, D>,
3508 offset: usize,
3509 _depth: fidl::encoding::Depth,
3510 ) -> fidl::Result<()> {
3511 encoder.debug_check_bounds::<ScanFilter>(offset);
3512 fidl::encoding::Encode::<ScanFilter, D>::encode(
3514 (
3515 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
3516 <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data_uuids),
3517 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_identifier),
3518 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3519 <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name_substring),
3520 <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.max_path_loss),
3521 ),
3522 encoder, offset, _depth
3523 )
3524 }
3525 }
3526 unsafe impl<
3527 D: fidl::encoding::ResourceDialect,
3528 T0: fidl::encoding::Encode<
3529 fidl::encoding::Optional<
3530 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3531 >,
3532 D,
3533 >,
3534 T1: fidl::encoding::Encode<
3535 fidl::encoding::Optional<
3536 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3537 >,
3538 D,
3539 >,
3540 T2: fidl::encoding::Encode<
3541 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3542 D,
3543 >,
3544 T3: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>, D>,
3545 T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
3546 T5: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3547 > fidl::encoding::Encode<ScanFilter, D> for (T0, T1, T2, T3, T4, T5)
3548 {
3549 #[inline]
3550 unsafe fn encode(
3551 self,
3552 encoder: &mut fidl::encoding::Encoder<'_, D>,
3553 offset: usize,
3554 depth: fidl::encoding::Depth,
3555 ) -> fidl::Result<()> {
3556 encoder.debug_check_bounds::<ScanFilter>(offset);
3557 self.0.encode(encoder, offset + 0, depth)?;
3561 self.1.encode(encoder, offset + 16, depth)?;
3562 self.2.encode(encoder, offset + 32, depth)?;
3563 self.3.encode(encoder, offset + 40, depth)?;
3564 self.4.encode(encoder, offset + 48, depth)?;
3565 self.5.encode(encoder, offset + 64, depth)?;
3566 Ok(())
3567 }
3568 }
3569
3570 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanFilter {
3571 #[inline(always)]
3572 fn new_empty() -> Self {
3573 Self {
3574 service_uuids: fidl::new_empty!(
3575 fidl::encoding::Optional<
3576 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3577 >,
3578 D
3579 ),
3580 service_data_uuids: fidl::new_empty!(
3581 fidl::encoding::Optional<
3582 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3583 >,
3584 D
3585 ),
3586 manufacturer_identifier: fidl::new_empty!(
3587 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3588 D
3589 ),
3590 connectable: fidl::new_empty!(
3591 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3592 D
3593 ),
3594 name_substring: fidl::new_empty!(
3595 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3596 D
3597 ),
3598 max_path_loss: fidl::new_empty!(
3599 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3600 D
3601 ),
3602 }
3603 }
3604
3605 #[inline]
3606 unsafe fn decode(
3607 &mut self,
3608 decoder: &mut fidl::encoding::Decoder<'_, D>,
3609 offset: usize,
3610 _depth: fidl::encoding::Depth,
3611 ) -> fidl::Result<()> {
3612 decoder.debug_check_bounds::<Self>(offset);
3613 fidl::decode!(
3615 fidl::encoding::Optional<
3616 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3617 >,
3618 D,
3619 &mut self.service_uuids,
3620 decoder,
3621 offset + 0,
3622 _depth
3623 )?;
3624 fidl::decode!(
3625 fidl::encoding::Optional<
3626 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3627 >,
3628 D,
3629 &mut self.service_data_uuids,
3630 decoder,
3631 offset + 16,
3632 _depth
3633 )?;
3634 fidl::decode!(
3635 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3636 D,
3637 &mut self.manufacturer_identifier,
3638 decoder,
3639 offset + 32,
3640 _depth
3641 )?;
3642 fidl::decode!(
3643 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3644 D,
3645 &mut self.connectable,
3646 decoder,
3647 offset + 40,
3648 _depth
3649 )?;
3650 fidl::decode!(
3651 fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3652 D,
3653 &mut self.name_substring,
3654 decoder,
3655 offset + 48,
3656 _depth
3657 )?;
3658 fidl::decode!(
3659 fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3660 D,
3661 &mut self.max_path_loss,
3662 decoder,
3663 offset + 64,
3664 _depth
3665 )?;
3666 Ok(())
3667 }
3668 }
3669
3670 impl fidl::encoding::ValueTypeMarker for ScanResultWatcherWatchResponse {
3671 type Borrowed<'a> = &'a Self;
3672 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673 value
3674 }
3675 }
3676
3677 unsafe impl fidl::encoding::TypeMarker for ScanResultWatcherWatchResponse {
3678 type Owned = Self;
3679
3680 #[inline(always)]
3681 fn inline_align(_context: fidl::encoding::Context) -> usize {
3682 8
3683 }
3684
3685 #[inline(always)]
3686 fn inline_size(_context: fidl::encoding::Context) -> usize {
3687 16
3688 }
3689 }
3690
3691 unsafe impl<D: fidl::encoding::ResourceDialect>
3692 fidl::encoding::Encode<ScanResultWatcherWatchResponse, D>
3693 for &ScanResultWatcherWatchResponse
3694 {
3695 #[inline]
3696 unsafe fn encode(
3697 self,
3698 encoder: &mut fidl::encoding::Encoder<'_, D>,
3699 offset: usize,
3700 _depth: fidl::encoding::Depth,
3701 ) -> fidl::Result<()> {
3702 encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3703 fidl::encoding::Encode::<ScanResultWatcherWatchResponse, D>::encode(
3705 (
3706 <fidl::encoding::UnboundedVector<Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.updated),
3707 ),
3708 encoder, offset, _depth
3709 )
3710 }
3711 }
3712 unsafe impl<
3713 D: fidl::encoding::ResourceDialect,
3714 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Peer>, D>,
3715 > fidl::encoding::Encode<ScanResultWatcherWatchResponse, D> for (T0,)
3716 {
3717 #[inline]
3718 unsafe fn encode(
3719 self,
3720 encoder: &mut fidl::encoding::Encoder<'_, D>,
3721 offset: usize,
3722 depth: fidl::encoding::Depth,
3723 ) -> fidl::Result<()> {
3724 encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3725 self.0.encode(encoder, offset + 0, depth)?;
3729 Ok(())
3730 }
3731 }
3732
3733 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3734 for ScanResultWatcherWatchResponse
3735 {
3736 #[inline(always)]
3737 fn new_empty() -> Self {
3738 Self { updated: fidl::new_empty!(fidl::encoding::UnboundedVector<Peer>, D) }
3739 }
3740
3741 #[inline]
3742 unsafe fn decode(
3743 &mut self,
3744 decoder: &mut fidl::encoding::Decoder<'_, D>,
3745 offset: usize,
3746 _depth: fidl::encoding::Depth,
3747 ) -> fidl::Result<()> {
3748 decoder.debug_check_bounds::<Self>(offset);
3749 fidl::decode!(
3751 fidl::encoding::UnboundedVector<Peer>,
3752 D,
3753 &mut self.updated,
3754 decoder,
3755 offset + 0,
3756 _depth
3757 )?;
3758 Ok(())
3759 }
3760 }
3761
3762 impl fidl::encoding::ValueTypeMarker for ServiceData {
3763 type Borrowed<'a> = &'a Self;
3764 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3765 value
3766 }
3767 }
3768
3769 unsafe impl fidl::encoding::TypeMarker for ServiceData {
3770 type Owned = Self;
3771
3772 #[inline(always)]
3773 fn inline_align(_context: fidl::encoding::Context) -> usize {
3774 8
3775 }
3776
3777 #[inline(always)]
3778 fn inline_size(_context: fidl::encoding::Context) -> usize {
3779 32
3780 }
3781 }
3782
3783 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceData, D>
3784 for &ServiceData
3785 {
3786 #[inline]
3787 unsafe fn encode(
3788 self,
3789 encoder: &mut fidl::encoding::Encoder<'_, D>,
3790 offset: usize,
3791 _depth: fidl::encoding::Depth,
3792 ) -> fidl::Result<()> {
3793 encoder.debug_check_bounds::<ServiceData>(offset);
3794 fidl::encoding::Encode::<ServiceData, D>::encode(
3796 (
3797 <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3798 <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3799 ),
3800 encoder, offset, _depth
3801 )
3802 }
3803 }
3804 unsafe impl<
3805 D: fidl::encoding::ResourceDialect,
3806 T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Uuid, D>,
3807 T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3808 > fidl::encoding::Encode<ServiceData, D> for (T0, T1)
3809 {
3810 #[inline]
3811 unsafe fn encode(
3812 self,
3813 encoder: &mut fidl::encoding::Encoder<'_, D>,
3814 offset: usize,
3815 depth: fidl::encoding::Depth,
3816 ) -> fidl::Result<()> {
3817 encoder.debug_check_bounds::<ServiceData>(offset);
3818 self.0.encode(encoder, offset + 0, depth)?;
3822 self.1.encode(encoder, offset + 16, depth)?;
3823 Ok(())
3824 }
3825 }
3826
3827 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceData {
3828 #[inline(always)]
3829 fn new_empty() -> Self {
3830 Self {
3831 uuid: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D),
3832 data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3833 }
3834 }
3835
3836 #[inline]
3837 unsafe fn decode(
3838 &mut self,
3839 decoder: &mut fidl::encoding::Decoder<'_, D>,
3840 offset: usize,
3841 _depth: fidl::encoding::Depth,
3842 ) -> fidl::Result<()> {
3843 decoder.debug_check_bounds::<Self>(offset);
3844 fidl::decode!(
3846 fidl_fuchsia_bluetooth__common::Uuid,
3847 D,
3848 &mut self.uuid,
3849 decoder,
3850 offset + 0,
3851 _depth
3852 )?;
3853 fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 16, _depth)?;
3854 Ok(())
3855 }
3856 }
3857
3858 impl fidl::encoding::ValueTypeMarker for ServiceDataEntry {
3859 type Borrowed<'a> = &'a Self;
3860 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3861 value
3862 }
3863 }
3864
3865 unsafe impl fidl::encoding::TypeMarker for ServiceDataEntry {
3866 type Owned = Self;
3867
3868 #[inline(always)]
3869 fn inline_align(_context: fidl::encoding::Context) -> usize {
3870 8
3871 }
3872
3873 #[inline(always)]
3874 fn inline_size(_context: fidl::encoding::Context) -> usize {
3875 32
3876 }
3877 }
3878
3879 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDataEntry, D>
3880 for &ServiceDataEntry
3881 {
3882 #[inline]
3883 unsafe fn encode(
3884 self,
3885 encoder: &mut fidl::encoding::Encoder<'_, D>,
3886 offset: usize,
3887 _depth: fidl::encoding::Depth,
3888 ) -> fidl::Result<()> {
3889 encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3890 fidl::encoding::Encode::<ServiceDataEntry, D>::encode(
3892 (
3893 <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3894 <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3895 ),
3896 encoder, offset, _depth
3897 )
3898 }
3899 }
3900 unsafe impl<
3901 D: fidl::encoding::ResourceDialect,
3902 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
3903 T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3904 > fidl::encoding::Encode<ServiceDataEntry, D> for (T0, T1)
3905 {
3906 #[inline]
3907 unsafe fn encode(
3908 self,
3909 encoder: &mut fidl::encoding::Encoder<'_, D>,
3910 offset: usize,
3911 depth: fidl::encoding::Depth,
3912 ) -> fidl::Result<()> {
3913 encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3914 self.0.encode(encoder, offset + 0, depth)?;
3918 self.1.encode(encoder, offset + 16, depth)?;
3919 Ok(())
3920 }
3921 }
3922
3923 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDataEntry {
3924 #[inline(always)]
3925 fn new_empty() -> Self {
3926 Self {
3927 uuid: fidl::new_empty!(fidl::encoding::BoundedString<36>, D),
3928 data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3929 }
3930 }
3931
3932 #[inline]
3933 unsafe fn decode(
3934 &mut self,
3935 decoder: &mut fidl::encoding::Decoder<'_, D>,
3936 offset: usize,
3937 _depth: fidl::encoding::Depth,
3938 ) -> fidl::Result<()> {
3939 decoder.debug_check_bounds::<Self>(offset);
3940 fidl::decode!(
3942 fidl::encoding::BoundedString<36>,
3943 D,
3944 &mut self.uuid,
3945 decoder,
3946 offset + 0,
3947 _depth
3948 )?;
3949 fidl::decode!(
3950 fidl::encoding::UnboundedVector<u8>,
3951 D,
3952 &mut self.data,
3953 decoder,
3954 offset + 16,
3955 _depth
3956 )?;
3957 Ok(())
3958 }
3959 }
3960
3961 impl AcceptedChannelParameters {
3962 #[inline(always)]
3963 fn max_ordinal_present(&self) -> u64 {
3964 if let Some(_) = self.max_packet_size {
3965 return 2;
3966 }
3967 if let Some(_) = self.accepted_channel_modes {
3968 return 1;
3969 }
3970 0
3971 }
3972 }
3973
3974 impl fidl::encoding::ValueTypeMarker for AcceptedChannelParameters {
3975 type Borrowed<'a> = &'a Self;
3976 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3977 value
3978 }
3979 }
3980
3981 unsafe impl fidl::encoding::TypeMarker for AcceptedChannelParameters {
3982 type Owned = Self;
3983
3984 #[inline(always)]
3985 fn inline_align(_context: fidl::encoding::Context) -> usize {
3986 8
3987 }
3988
3989 #[inline(always)]
3990 fn inline_size(_context: fidl::encoding::Context) -> usize {
3991 16
3992 }
3993 }
3994
3995 unsafe impl<D: fidl::encoding::ResourceDialect>
3996 fidl::encoding::Encode<AcceptedChannelParameters, D> for &AcceptedChannelParameters
3997 {
3998 unsafe fn encode(
3999 self,
4000 encoder: &mut fidl::encoding::Encoder<'_, D>,
4001 offset: usize,
4002 mut depth: fidl::encoding::Depth,
4003 ) -> fidl::Result<()> {
4004 encoder.debug_check_bounds::<AcceptedChannelParameters>(offset);
4005 let max_ordinal: u64 = self.max_ordinal_present();
4007 encoder.write_num(max_ordinal, offset);
4008 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4009 if max_ordinal == 0 {
4011 return Ok(());
4012 }
4013 depth.increment()?;
4014 let envelope_size = 8;
4015 let bytes_len = max_ordinal as usize * envelope_size;
4016 #[allow(unused_variables)]
4017 let offset = encoder.out_of_line_offset(bytes_len);
4018 let mut _prev_end_offset: usize = 0;
4019 if 1 > max_ordinal {
4020 return Ok(());
4021 }
4022
4023 let cur_offset: usize = (1 - 1) * envelope_size;
4026
4027 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4029
4030 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>, D>(
4035 self.accepted_channel_modes.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode> as fidl::encoding::ValueTypeMarker>::borrow),
4036 encoder, offset + cur_offset, depth
4037 )?;
4038
4039 _prev_end_offset = cur_offset + envelope_size;
4040 if 2 > max_ordinal {
4041 return Ok(());
4042 }
4043
4044 let cur_offset: usize = (2 - 1) * envelope_size;
4047
4048 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4050
4051 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4056 self.max_packet_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4057 encoder,
4058 offset + cur_offset,
4059 depth,
4060 )?;
4061
4062 _prev_end_offset = cur_offset + envelope_size;
4063
4064 Ok(())
4065 }
4066 }
4067
4068 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4069 for AcceptedChannelParameters
4070 {
4071 #[inline(always)]
4072 fn new_empty() -> Self {
4073 Self::default()
4074 }
4075
4076 unsafe fn decode(
4077 &mut self,
4078 decoder: &mut fidl::encoding::Decoder<'_, D>,
4079 offset: usize,
4080 mut depth: fidl::encoding::Depth,
4081 ) -> fidl::Result<()> {
4082 decoder.debug_check_bounds::<Self>(offset);
4083 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4084 None => return Err(fidl::Error::NotNullable),
4085 Some(len) => len,
4086 };
4087 if len == 0 {
4089 return Ok(());
4090 };
4091 depth.increment()?;
4092 let envelope_size = 8;
4093 let bytes_len = len * envelope_size;
4094 let offset = decoder.out_of_line_offset(bytes_len)?;
4095 let mut _next_ordinal_to_read = 0;
4097 let mut next_offset = offset;
4098 let end_offset = offset + bytes_len;
4099 _next_ordinal_to_read += 1;
4100 if next_offset >= end_offset {
4101 return Ok(());
4102 }
4103
4104 while _next_ordinal_to_read < 1 {
4106 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4107 _next_ordinal_to_read += 1;
4108 next_offset += envelope_size;
4109 }
4110
4111 let next_out_of_line = decoder.next_out_of_line();
4112 let handles_before = decoder.remaining_handles();
4113 if let Some((inlined, num_bytes, num_handles)) =
4114 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4115 {
4116 let member_inline_size = <fidl::encoding::UnboundedVector<
4117 fidl_fuchsia_bluetooth__common::ChannelMode,
4118 > as fidl::encoding::TypeMarker>::inline_size(
4119 decoder.context
4120 );
4121 if inlined != (member_inline_size <= 4) {
4122 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4123 }
4124 let inner_offset;
4125 let mut inner_depth = depth.clone();
4126 if inlined {
4127 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4128 inner_offset = next_offset;
4129 } else {
4130 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4131 inner_depth.increment()?;
4132 }
4133 let val_ref = self.accepted_channel_modes.get_or_insert_with(|| {
4134 fidl::new_empty!(
4135 fidl::encoding::UnboundedVector<
4136 fidl_fuchsia_bluetooth__common::ChannelMode,
4137 >,
4138 D
4139 )
4140 });
4141 fidl::decode!(
4142 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>,
4143 D,
4144 val_ref,
4145 decoder,
4146 inner_offset,
4147 inner_depth
4148 )?;
4149 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4150 {
4151 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4152 }
4153 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4154 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4155 }
4156 }
4157
4158 next_offset += envelope_size;
4159 _next_ordinal_to_read += 1;
4160 if next_offset >= end_offset {
4161 return Ok(());
4162 }
4163
4164 while _next_ordinal_to_read < 2 {
4166 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4167 _next_ordinal_to_read += 1;
4168 next_offset += envelope_size;
4169 }
4170
4171 let next_out_of_line = decoder.next_out_of_line();
4172 let handles_before = decoder.remaining_handles();
4173 if let Some((inlined, num_bytes, num_handles)) =
4174 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4175 {
4176 let member_inline_size =
4177 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4178 if inlined != (member_inline_size <= 4) {
4179 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4180 }
4181 let inner_offset;
4182 let mut inner_depth = depth.clone();
4183 if inlined {
4184 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4185 inner_offset = next_offset;
4186 } else {
4187 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4188 inner_depth.increment()?;
4189 }
4190 let val_ref = self.max_packet_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
4191 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4192 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4193 {
4194 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4195 }
4196 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4197 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4198 }
4199 }
4200
4201 next_offset += envelope_size;
4202
4203 while next_offset < end_offset {
4205 _next_ordinal_to_read += 1;
4206 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4207 next_offset += envelope_size;
4208 }
4209
4210 Ok(())
4211 }
4212 }
4213
4214 impl AdvertisingData {
4215 #[inline(always)]
4216 fn max_ordinal_present(&self) -> u64 {
4217 if let Some(_) = self.broadcast_name {
4218 return 10;
4219 }
4220 if let Some(_) = self.resolvable_set_identifier {
4221 return 9;
4222 }
4223 if let Some(_) = self.include_tx_power_level {
4224 return 8;
4225 }
4226 if let Some(_) = self.uris {
4227 return 7;
4228 }
4229 if let Some(_) = self.manufacturer_data {
4230 return 6;
4231 }
4232 if let Some(_) = self.service_data {
4233 return 5;
4234 }
4235 if let Some(_) = self.service_uuids {
4236 return 4;
4237 }
4238 if let Some(_) = self.tx_power_level {
4239 return 3;
4240 }
4241 if let Some(_) = self.appearance {
4242 return 2;
4243 }
4244 if let Some(_) = self.name {
4245 return 1;
4246 }
4247 0
4248 }
4249 }
4250
4251 impl fidl::encoding::ValueTypeMarker for AdvertisingData {
4252 type Borrowed<'a> = &'a Self;
4253 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4254 value
4255 }
4256 }
4257
4258 unsafe impl fidl::encoding::TypeMarker for AdvertisingData {
4259 type Owned = Self;
4260
4261 #[inline(always)]
4262 fn inline_align(_context: fidl::encoding::Context) -> usize {
4263 8
4264 }
4265
4266 #[inline(always)]
4267 fn inline_size(_context: fidl::encoding::Context) -> usize {
4268 16
4269 }
4270 }
4271
4272 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingData, D>
4273 for &AdvertisingData
4274 {
4275 unsafe fn encode(
4276 self,
4277 encoder: &mut fidl::encoding::Encoder<'_, D>,
4278 offset: usize,
4279 mut depth: fidl::encoding::Depth,
4280 ) -> fidl::Result<()> {
4281 encoder.debug_check_bounds::<AdvertisingData>(offset);
4282 let max_ordinal: u64 = self.max_ordinal_present();
4284 encoder.write_num(max_ordinal, offset);
4285 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4286 if max_ordinal == 0 {
4288 return Ok(());
4289 }
4290 depth.increment()?;
4291 let envelope_size = 8;
4292 let bytes_len = max_ordinal as usize * envelope_size;
4293 #[allow(unused_variables)]
4294 let offset = encoder.out_of_line_offset(bytes_len);
4295 let mut _prev_end_offset: usize = 0;
4296 if 1 > max_ordinal {
4297 return Ok(());
4298 }
4299
4300 let cur_offset: usize = (1 - 1) * envelope_size;
4303
4304 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4306
4307 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
4312 self.name.as_ref().map(
4313 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
4314 ),
4315 encoder,
4316 offset + cur_offset,
4317 depth,
4318 )?;
4319
4320 _prev_end_offset = cur_offset + envelope_size;
4321 if 2 > max_ordinal {
4322 return Ok(());
4323 }
4324
4325 let cur_offset: usize = (2 - 1) * envelope_size;
4328
4329 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4331
4332 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
4337 self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
4338 encoder, offset + cur_offset, depth
4339 )?;
4340
4341 _prev_end_offset = cur_offset + envelope_size;
4342 if 3 > max_ordinal {
4343 return Ok(());
4344 }
4345
4346 let cur_offset: usize = (3 - 1) * envelope_size;
4349
4350 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4352
4353 fidl::encoding::encode_in_envelope_optional::<i8, D>(
4358 self.tx_power_level.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4359 encoder,
4360 offset + cur_offset,
4361 depth,
4362 )?;
4363
4364 _prev_end_offset = cur_offset + envelope_size;
4365 if 4 > max_ordinal {
4366 return Ok(());
4367 }
4368
4369 let cur_offset: usize = (4 - 1) * envelope_size;
4372
4373 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4375
4376 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
4381 self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
4382 encoder, offset + cur_offset, depth
4383 )?;
4384
4385 _prev_end_offset = cur_offset + envelope_size;
4386 if 5 > max_ordinal {
4387 return Ok(());
4388 }
4389
4390 let cur_offset: usize = (5 - 1) * envelope_size;
4393
4394 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4396
4397 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
4402 self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
4403 encoder, offset + cur_offset, depth
4404 )?;
4405
4406 _prev_end_offset = cur_offset + envelope_size;
4407 if 6 > max_ordinal {
4408 return Ok(());
4409 }
4410
4411 let cur_offset: usize = (6 - 1) * envelope_size;
4414
4415 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4417
4418 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
4423 self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
4424 encoder, offset + cur_offset, depth
4425 )?;
4426
4427 _prev_end_offset = cur_offset + envelope_size;
4428 if 7 > max_ordinal {
4429 return Ok(());
4430 }
4431
4432 let cur_offset: usize = (7 - 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::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
4444 self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
4445 encoder, offset + cur_offset, depth
4446 )?;
4447
4448 _prev_end_offset = cur_offset + envelope_size;
4449 if 8 > max_ordinal {
4450 return Ok(());
4451 }
4452
4453 let cur_offset: usize = (8 - 1) * envelope_size;
4456
4457 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4459
4460 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4465 self.include_tx_power_level
4466 .as_ref()
4467 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4468 encoder,
4469 offset + cur_offset,
4470 depth,
4471 )?;
4472
4473 _prev_end_offset = cur_offset + envelope_size;
4474 if 9 > max_ordinal {
4475 return Ok(());
4476 }
4477
4478 let cur_offset: usize = (9 - 1) * envelope_size;
4481
4482 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4484
4485 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4490 self.resolvable_set_identifier
4491 .as_ref()
4492 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4493 encoder,
4494 offset + cur_offset,
4495 depth,
4496 )?;
4497
4498 _prev_end_offset = cur_offset + envelope_size;
4499 if 10 > max_ordinal {
4500 return Ok(());
4501 }
4502
4503 let cur_offset: usize = (10 - 1) * envelope_size;
4506
4507 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4509
4510 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
4515 self.broadcast_name.as_ref().map(
4516 <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
4517 ),
4518 encoder,
4519 offset + cur_offset,
4520 depth,
4521 )?;
4522
4523 _prev_end_offset = cur_offset + envelope_size;
4524
4525 Ok(())
4526 }
4527 }
4528
4529 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingData {
4530 #[inline(always)]
4531 fn new_empty() -> Self {
4532 Self::default()
4533 }
4534
4535 unsafe fn decode(
4536 &mut self,
4537 decoder: &mut fidl::encoding::Decoder<'_, D>,
4538 offset: usize,
4539 mut depth: fidl::encoding::Depth,
4540 ) -> fidl::Result<()> {
4541 decoder.debug_check_bounds::<Self>(offset);
4542 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4543 None => return Err(fidl::Error::NotNullable),
4544 Some(len) => len,
4545 };
4546 if len == 0 {
4548 return Ok(());
4549 };
4550 depth.increment()?;
4551 let envelope_size = 8;
4552 let bytes_len = len * envelope_size;
4553 let offset = decoder.out_of_line_offset(bytes_len)?;
4554 let mut _next_ordinal_to_read = 0;
4556 let mut next_offset = offset;
4557 let end_offset = offset + bytes_len;
4558 _next_ordinal_to_read += 1;
4559 if next_offset >= end_offset {
4560 return Ok(());
4561 }
4562
4563 while _next_ordinal_to_read < 1 {
4565 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4566 _next_ordinal_to_read += 1;
4567 next_offset += envelope_size;
4568 }
4569
4570 let next_out_of_line = decoder.next_out_of_line();
4571 let handles_before = decoder.remaining_handles();
4572 if let Some((inlined, num_bytes, num_handles)) =
4573 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4574 {
4575 let member_inline_size =
4576 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
4577 decoder.context,
4578 );
4579 if inlined != (member_inline_size <= 4) {
4580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4581 }
4582 let inner_offset;
4583 let mut inner_depth = depth.clone();
4584 if inlined {
4585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4586 inner_offset = next_offset;
4587 } else {
4588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4589 inner_depth.increment()?;
4590 }
4591 let val_ref = self
4592 .name
4593 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
4594 fidl::decode!(
4595 fidl::encoding::BoundedString<248>,
4596 D,
4597 val_ref,
4598 decoder,
4599 inner_offset,
4600 inner_depth
4601 )?;
4602 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4603 {
4604 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4605 }
4606 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4607 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4608 }
4609 }
4610
4611 next_offset += envelope_size;
4612 _next_ordinal_to_read += 1;
4613 if next_offset >= end_offset {
4614 return Ok(());
4615 }
4616
4617 while _next_ordinal_to_read < 2 {
4619 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4620 _next_ordinal_to_read += 1;
4621 next_offset += envelope_size;
4622 }
4623
4624 let next_out_of_line = decoder.next_out_of_line();
4625 let handles_before = decoder.remaining_handles();
4626 if let Some((inlined, num_bytes, num_handles)) =
4627 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4628 {
4629 let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4630 if inlined != (member_inline_size <= 4) {
4631 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4632 }
4633 let inner_offset;
4634 let mut inner_depth = depth.clone();
4635 if inlined {
4636 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4637 inner_offset = next_offset;
4638 } else {
4639 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4640 inner_depth.increment()?;
4641 }
4642 let val_ref = self.appearance.get_or_insert_with(|| {
4643 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
4644 });
4645 fidl::decode!(
4646 fidl_fuchsia_bluetooth__common::Appearance,
4647 D,
4648 val_ref,
4649 decoder,
4650 inner_offset,
4651 inner_depth
4652 )?;
4653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4654 {
4655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4656 }
4657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4659 }
4660 }
4661
4662 next_offset += envelope_size;
4663 _next_ordinal_to_read += 1;
4664 if next_offset >= end_offset {
4665 return Ok(());
4666 }
4667
4668 while _next_ordinal_to_read < 3 {
4670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4671 _next_ordinal_to_read += 1;
4672 next_offset += envelope_size;
4673 }
4674
4675 let next_out_of_line = decoder.next_out_of_line();
4676 let handles_before = decoder.remaining_handles();
4677 if let Some((inlined, num_bytes, num_handles)) =
4678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4679 {
4680 let member_inline_size =
4681 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4682 if inlined != (member_inline_size <= 4) {
4683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4684 }
4685 let inner_offset;
4686 let mut inner_depth = depth.clone();
4687 if inlined {
4688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4689 inner_offset = next_offset;
4690 } else {
4691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4692 inner_depth.increment()?;
4693 }
4694 let val_ref = self.tx_power_level.get_or_insert_with(|| fidl::new_empty!(i8, D));
4695 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
4696 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4697 {
4698 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4699 }
4700 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4701 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4702 }
4703 }
4704
4705 next_offset += envelope_size;
4706 _next_ordinal_to_read += 1;
4707 if next_offset >= end_offset {
4708 return Ok(());
4709 }
4710
4711 while _next_ordinal_to_read < 4 {
4713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4714 _next_ordinal_to_read += 1;
4715 next_offset += envelope_size;
4716 }
4717
4718 let next_out_of_line = decoder.next_out_of_line();
4719 let handles_before = decoder.remaining_handles();
4720 if let Some((inlined, num_bytes, num_handles)) =
4721 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4722 {
4723 let member_inline_size = <fidl::encoding::UnboundedVector<
4724 fidl_fuchsia_bluetooth__common::Uuid,
4725 > as fidl::encoding::TypeMarker>::inline_size(
4726 decoder.context
4727 );
4728 if inlined != (member_inline_size <= 4) {
4729 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4730 }
4731 let inner_offset;
4732 let mut inner_depth = depth.clone();
4733 if inlined {
4734 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4735 inner_offset = next_offset;
4736 } else {
4737 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4738 inner_depth.increment()?;
4739 }
4740 let val_ref = self.service_uuids.get_or_insert_with(|| {
4741 fidl::new_empty!(
4742 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4743 D
4744 )
4745 });
4746 fidl::decode!(
4747 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4748 D,
4749 val_ref,
4750 decoder,
4751 inner_offset,
4752 inner_depth
4753 )?;
4754 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4755 {
4756 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4757 }
4758 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4759 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4760 }
4761 }
4762
4763 next_offset += envelope_size;
4764 _next_ordinal_to_read += 1;
4765 if next_offset >= end_offset {
4766 return Ok(());
4767 }
4768
4769 while _next_ordinal_to_read < 5 {
4771 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4772 _next_ordinal_to_read += 1;
4773 next_offset += envelope_size;
4774 }
4775
4776 let next_out_of_line = decoder.next_out_of_line();
4777 let handles_before = decoder.remaining_handles();
4778 if let Some((inlined, num_bytes, num_handles)) =
4779 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4780 {
4781 let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4782 if inlined != (member_inline_size <= 4) {
4783 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4784 }
4785 let inner_offset;
4786 let mut inner_depth = depth.clone();
4787 if inlined {
4788 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4789 inner_offset = next_offset;
4790 } else {
4791 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4792 inner_depth.increment()?;
4793 }
4794 let val_ref = self.service_data.get_or_insert_with(|| {
4795 fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
4796 });
4797 fidl::decode!(
4798 fidl::encoding::UnboundedVector<ServiceData>,
4799 D,
4800 val_ref,
4801 decoder,
4802 inner_offset,
4803 inner_depth
4804 )?;
4805 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4806 {
4807 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4808 }
4809 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4810 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4811 }
4812 }
4813
4814 next_offset += envelope_size;
4815 _next_ordinal_to_read += 1;
4816 if next_offset >= end_offset {
4817 return Ok(());
4818 }
4819
4820 while _next_ordinal_to_read < 6 {
4822 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4823 _next_ordinal_to_read += 1;
4824 next_offset += envelope_size;
4825 }
4826
4827 let next_out_of_line = decoder.next_out_of_line();
4828 let handles_before = decoder.remaining_handles();
4829 if let Some((inlined, num_bytes, num_handles)) =
4830 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4831 {
4832 let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4833 if inlined != (member_inline_size <= 4) {
4834 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4835 }
4836 let inner_offset;
4837 let mut inner_depth = depth.clone();
4838 if inlined {
4839 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4840 inner_offset = next_offset;
4841 } else {
4842 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4843 inner_depth.increment()?;
4844 }
4845 let val_ref = self.manufacturer_data.get_or_insert_with(|| {
4846 fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
4847 });
4848 fidl::decode!(
4849 fidl::encoding::UnboundedVector<ManufacturerData>,
4850 D,
4851 val_ref,
4852 decoder,
4853 inner_offset,
4854 inner_depth
4855 )?;
4856 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4857 {
4858 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4859 }
4860 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4861 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4862 }
4863 }
4864
4865 next_offset += envelope_size;
4866 _next_ordinal_to_read += 1;
4867 if next_offset >= end_offset {
4868 return Ok(());
4869 }
4870
4871 while _next_ordinal_to_read < 7 {
4873 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4874 _next_ordinal_to_read += 1;
4875 next_offset += envelope_size;
4876 }
4877
4878 let next_out_of_line = decoder.next_out_of_line();
4879 let handles_before = decoder.remaining_handles();
4880 if let Some((inlined, num_bytes, num_handles)) =
4881 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4882 {
4883 let member_inline_size = <fidl::encoding::UnboundedVector<
4884 fidl::encoding::BoundedString<278>,
4885 > as fidl::encoding::TypeMarker>::inline_size(
4886 decoder.context
4887 );
4888 if inlined != (member_inline_size <= 4) {
4889 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4890 }
4891 let inner_offset;
4892 let mut inner_depth = depth.clone();
4893 if inlined {
4894 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4895 inner_offset = next_offset;
4896 } else {
4897 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4898 inner_depth.increment()?;
4899 }
4900 let val_ref = self.uris.get_or_insert_with(|| {
4901 fidl::new_empty!(
4902 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4903 D
4904 )
4905 });
4906 fidl::decode!(
4907 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4908 D,
4909 val_ref,
4910 decoder,
4911 inner_offset,
4912 inner_depth
4913 )?;
4914 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4915 {
4916 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4917 }
4918 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4919 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4920 }
4921 }
4922
4923 next_offset += envelope_size;
4924 _next_ordinal_to_read += 1;
4925 if next_offset >= end_offset {
4926 return Ok(());
4927 }
4928
4929 while _next_ordinal_to_read < 8 {
4931 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4932 _next_ordinal_to_read += 1;
4933 next_offset += envelope_size;
4934 }
4935
4936 let next_out_of_line = decoder.next_out_of_line();
4937 let handles_before = decoder.remaining_handles();
4938 if let Some((inlined, num_bytes, num_handles)) =
4939 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4940 {
4941 let member_inline_size =
4942 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4943 if inlined != (member_inline_size <= 4) {
4944 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4945 }
4946 let inner_offset;
4947 let mut inner_depth = depth.clone();
4948 if inlined {
4949 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4950 inner_offset = next_offset;
4951 } else {
4952 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4953 inner_depth.increment()?;
4954 }
4955 let val_ref =
4956 self.include_tx_power_level.get_or_insert_with(|| fidl::new_empty!(bool, D));
4957 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4958 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4959 {
4960 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4961 }
4962 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4963 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4964 }
4965 }
4966
4967 next_offset += envelope_size;
4968 _next_ordinal_to_read += 1;
4969 if next_offset >= end_offset {
4970 return Ok(());
4971 }
4972
4973 while _next_ordinal_to_read < 9 {
4975 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4976 _next_ordinal_to_read += 1;
4977 next_offset += envelope_size;
4978 }
4979
4980 let next_out_of_line = decoder.next_out_of_line();
4981 let handles_before = decoder.remaining_handles();
4982 if let Some((inlined, num_bytes, num_handles)) =
4983 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4984 {
4985 let member_inline_size =
4986 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4987 decoder.context,
4988 );
4989 if inlined != (member_inline_size <= 4) {
4990 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4991 }
4992 let inner_offset;
4993 let mut inner_depth = depth.clone();
4994 if inlined {
4995 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4996 inner_offset = next_offset;
4997 } else {
4998 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4999 inner_depth.increment()?;
5000 }
5001 let val_ref = self
5002 .resolvable_set_identifier
5003 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5004 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5006 {
5007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5008 }
5009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5011 }
5012 }
5013
5014 next_offset += envelope_size;
5015 _next_ordinal_to_read += 1;
5016 if next_offset >= end_offset {
5017 return Ok(());
5018 }
5019
5020 while _next_ordinal_to_read < 10 {
5022 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5023 _next_ordinal_to_read += 1;
5024 next_offset += envelope_size;
5025 }
5026
5027 let next_out_of_line = decoder.next_out_of_line();
5028 let handles_before = decoder.remaining_handles();
5029 if let Some((inlined, num_bytes, num_handles)) =
5030 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5031 {
5032 let member_inline_size =
5033 <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5034 decoder.context,
5035 );
5036 if inlined != (member_inline_size <= 4) {
5037 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5038 }
5039 let inner_offset;
5040 let mut inner_depth = depth.clone();
5041 if inlined {
5042 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5043 inner_offset = next_offset;
5044 } else {
5045 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5046 inner_depth.increment()?;
5047 }
5048 let val_ref = self
5049 .broadcast_name
5050 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5051 fidl::decode!(
5052 fidl::encoding::BoundedString<128>,
5053 D,
5054 val_ref,
5055 decoder,
5056 inner_offset,
5057 inner_depth
5058 )?;
5059 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5060 {
5061 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5062 }
5063 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5064 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5065 }
5066 }
5067
5068 next_offset += envelope_size;
5069
5070 while next_offset < end_offset {
5072 _next_ordinal_to_read += 1;
5073 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5074 next_offset += envelope_size;
5075 }
5076
5077 Ok(())
5078 }
5079 }
5080
5081 impl AdvertisingParameters {
5082 #[inline(always)]
5083 fn max_ordinal_present(&self) -> u64 {
5084 if let Some(_) = self.address_type {
5085 return 7;
5086 }
5087 if let Some(_) = self.advertising_procedure {
5088 return 6;
5089 }
5090 if let Some(_) = self.connection_options {
5091 return 5;
5092 }
5093 if let Some(_) = self.connectable {
5094 return 4;
5095 }
5096 if let Some(_) = self.mode_hint {
5097 return 3;
5098 }
5099 if let Some(_) = self.scan_response {
5100 return 2;
5101 }
5102 if let Some(_) = self.data {
5103 return 1;
5104 }
5105 0
5106 }
5107 }
5108
5109 impl fidl::encoding::ValueTypeMarker for AdvertisingParameters {
5110 type Borrowed<'a> = &'a Self;
5111 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5112 value
5113 }
5114 }
5115
5116 unsafe impl fidl::encoding::TypeMarker for AdvertisingParameters {
5117 type Owned = Self;
5118
5119 #[inline(always)]
5120 fn inline_align(_context: fidl::encoding::Context) -> usize {
5121 8
5122 }
5123
5124 #[inline(always)]
5125 fn inline_size(_context: fidl::encoding::Context) -> usize {
5126 16
5127 }
5128 }
5129
5130 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingParameters, D>
5131 for &AdvertisingParameters
5132 {
5133 unsafe fn encode(
5134 self,
5135 encoder: &mut fidl::encoding::Encoder<'_, D>,
5136 offset: usize,
5137 mut depth: fidl::encoding::Depth,
5138 ) -> fidl::Result<()> {
5139 encoder.debug_check_bounds::<AdvertisingParameters>(offset);
5140 let max_ordinal: u64 = self.max_ordinal_present();
5142 encoder.write_num(max_ordinal, offset);
5143 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5144 if max_ordinal == 0 {
5146 return Ok(());
5147 }
5148 depth.increment()?;
5149 let envelope_size = 8;
5150 let bytes_len = max_ordinal as usize * envelope_size;
5151 #[allow(unused_variables)]
5152 let offset = encoder.out_of_line_offset(bytes_len);
5153 let mut _prev_end_offset: usize = 0;
5154 if 1 > max_ordinal {
5155 return Ok(());
5156 }
5157
5158 let cur_offset: usize = (1 - 1) * envelope_size;
5161
5162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5164
5165 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5170 self.data
5171 .as_ref()
5172 .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5173 encoder,
5174 offset + cur_offset,
5175 depth,
5176 )?;
5177
5178 _prev_end_offset = cur_offset + envelope_size;
5179 if 2 > max_ordinal {
5180 return Ok(());
5181 }
5182
5183 let cur_offset: usize = (2 - 1) * envelope_size;
5186
5187 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5189
5190 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5195 self.scan_response
5196 .as_ref()
5197 .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5198 encoder,
5199 offset + cur_offset,
5200 depth,
5201 )?;
5202
5203 _prev_end_offset = cur_offset + envelope_size;
5204 if 3 > max_ordinal {
5205 return Ok(());
5206 }
5207
5208 let cur_offset: usize = (3 - 1) * envelope_size;
5211
5212 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5214
5215 fidl::encoding::encode_in_envelope_optional::<AdvertisingModeHint, D>(
5220 self.mode_hint
5221 .as_ref()
5222 .map(<AdvertisingModeHint as fidl::encoding::ValueTypeMarker>::borrow),
5223 encoder,
5224 offset + cur_offset,
5225 depth,
5226 )?;
5227
5228 _prev_end_offset = cur_offset + envelope_size;
5229 if 4 > max_ordinal {
5230 return Ok(());
5231 }
5232
5233 let cur_offset: usize = (4 - 1) * envelope_size;
5236
5237 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5239
5240 fidl::encoding::encode_in_envelope_optional::<bool, D>(
5245 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5246 encoder,
5247 offset + cur_offset,
5248 depth,
5249 )?;
5250
5251 _prev_end_offset = cur_offset + envelope_size;
5252 if 5 > max_ordinal {
5253 return Ok(());
5254 }
5255
5256 let cur_offset: usize = (5 - 1) * envelope_size;
5259
5260 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5262
5263 fidl::encoding::encode_in_envelope_optional::<ConnectionOptions, D>(
5268 self.connection_options
5269 .as_ref()
5270 .map(<ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow),
5271 encoder,
5272 offset + cur_offset,
5273 depth,
5274 )?;
5275
5276 _prev_end_offset = cur_offset + envelope_size;
5277 if 6 > max_ordinal {
5278 return Ok(());
5279 }
5280
5281 let cur_offset: usize = (6 - 1) * envelope_size;
5284
5285 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5287
5288 fidl::encoding::encode_in_envelope_optional::<AdvertisingProcedure, D>(
5293 self.advertising_procedure
5294 .as_ref()
5295 .map(<AdvertisingProcedure as fidl::encoding::ValueTypeMarker>::borrow),
5296 encoder,
5297 offset + cur_offset,
5298 depth,
5299 )?;
5300
5301 _prev_end_offset = cur_offset + envelope_size;
5302 if 7 > max_ordinal {
5303 return Ok(());
5304 }
5305
5306 let cur_offset: usize = (7 - 1) * envelope_size;
5309
5310 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5312
5313 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AddressType, D>(
5318 self.address_type.as_ref().map(<fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::ValueTypeMarker>::borrow),
5319 encoder, offset + cur_offset, depth
5320 )?;
5321
5322 _prev_end_offset = cur_offset + envelope_size;
5323
5324 Ok(())
5325 }
5326 }
5327
5328 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingParameters {
5329 #[inline(always)]
5330 fn new_empty() -> Self {
5331 Self::default()
5332 }
5333
5334 unsafe fn decode(
5335 &mut self,
5336 decoder: &mut fidl::encoding::Decoder<'_, D>,
5337 offset: usize,
5338 mut depth: fidl::encoding::Depth,
5339 ) -> fidl::Result<()> {
5340 decoder.debug_check_bounds::<Self>(offset);
5341 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5342 None => return Err(fidl::Error::NotNullable),
5343 Some(len) => len,
5344 };
5345 if len == 0 {
5347 return Ok(());
5348 };
5349 depth.increment()?;
5350 let envelope_size = 8;
5351 let bytes_len = len * envelope_size;
5352 let offset = decoder.out_of_line_offset(bytes_len)?;
5353 let mut _next_ordinal_to_read = 0;
5355 let mut next_offset = offset;
5356 let end_offset = offset + bytes_len;
5357 _next_ordinal_to_read += 1;
5358 if next_offset >= end_offset {
5359 return Ok(());
5360 }
5361
5362 while _next_ordinal_to_read < 1 {
5364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5365 _next_ordinal_to_read += 1;
5366 next_offset += envelope_size;
5367 }
5368
5369 let next_out_of_line = decoder.next_out_of_line();
5370 let handles_before = decoder.remaining_handles();
5371 if let Some((inlined, num_bytes, num_handles)) =
5372 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5373 {
5374 let member_inline_size =
5375 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5376 if inlined != (member_inline_size <= 4) {
5377 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5378 }
5379 let inner_offset;
5380 let mut inner_depth = depth.clone();
5381 if inlined {
5382 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5383 inner_offset = next_offset;
5384 } else {
5385 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5386 inner_depth.increment()?;
5387 }
5388 let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5389 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5390 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5391 {
5392 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5393 }
5394 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5395 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5396 }
5397 }
5398
5399 next_offset += envelope_size;
5400 _next_ordinal_to_read += 1;
5401 if next_offset >= end_offset {
5402 return Ok(());
5403 }
5404
5405 while _next_ordinal_to_read < 2 {
5407 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5408 _next_ordinal_to_read += 1;
5409 next_offset += envelope_size;
5410 }
5411
5412 let next_out_of_line = decoder.next_out_of_line();
5413 let handles_before = decoder.remaining_handles();
5414 if let Some((inlined, num_bytes, num_handles)) =
5415 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5416 {
5417 let member_inline_size =
5418 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5419 if inlined != (member_inline_size <= 4) {
5420 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5421 }
5422 let inner_offset;
5423 let mut inner_depth = depth.clone();
5424 if inlined {
5425 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5426 inner_offset = next_offset;
5427 } else {
5428 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5429 inner_depth.increment()?;
5430 }
5431 let val_ref =
5432 self.scan_response.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5433 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5434 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5435 {
5436 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5437 }
5438 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5439 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5440 }
5441 }
5442
5443 next_offset += envelope_size;
5444 _next_ordinal_to_read += 1;
5445 if next_offset >= end_offset {
5446 return Ok(());
5447 }
5448
5449 while _next_ordinal_to_read < 3 {
5451 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5452 _next_ordinal_to_read += 1;
5453 next_offset += envelope_size;
5454 }
5455
5456 let next_out_of_line = decoder.next_out_of_line();
5457 let handles_before = decoder.remaining_handles();
5458 if let Some((inlined, num_bytes, num_handles)) =
5459 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5460 {
5461 let member_inline_size =
5462 <AdvertisingModeHint as fidl::encoding::TypeMarker>::inline_size(
5463 decoder.context,
5464 );
5465 if inlined != (member_inline_size <= 4) {
5466 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5467 }
5468 let inner_offset;
5469 let mut inner_depth = depth.clone();
5470 if inlined {
5471 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5472 inner_offset = next_offset;
5473 } else {
5474 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5475 inner_depth.increment()?;
5476 }
5477 let val_ref =
5478 self.mode_hint.get_or_insert_with(|| fidl::new_empty!(AdvertisingModeHint, D));
5479 fidl::decode!(AdvertisingModeHint, D, val_ref, decoder, inner_offset, inner_depth)?;
5480 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5481 {
5482 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5483 }
5484 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5485 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5486 }
5487 }
5488
5489 next_offset += envelope_size;
5490 _next_ordinal_to_read += 1;
5491 if next_offset >= end_offset {
5492 return Ok(());
5493 }
5494
5495 while _next_ordinal_to_read < 4 {
5497 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5498 _next_ordinal_to_read += 1;
5499 next_offset += envelope_size;
5500 }
5501
5502 let next_out_of_line = decoder.next_out_of_line();
5503 let handles_before = decoder.remaining_handles();
5504 if let Some((inlined, num_bytes, num_handles)) =
5505 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5506 {
5507 let member_inline_size =
5508 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5509 if inlined != (member_inline_size <= 4) {
5510 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5511 }
5512 let inner_offset;
5513 let mut inner_depth = depth.clone();
5514 if inlined {
5515 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5516 inner_offset = next_offset;
5517 } else {
5518 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5519 inner_depth.increment()?;
5520 }
5521 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5522 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5523 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5524 {
5525 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5526 }
5527 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5528 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5529 }
5530 }
5531
5532 next_offset += envelope_size;
5533 _next_ordinal_to_read += 1;
5534 if next_offset >= end_offset {
5535 return Ok(());
5536 }
5537
5538 while _next_ordinal_to_read < 5 {
5540 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5541 _next_ordinal_to_read += 1;
5542 next_offset += envelope_size;
5543 }
5544
5545 let next_out_of_line = decoder.next_out_of_line();
5546 let handles_before = decoder.remaining_handles();
5547 if let Some((inlined, num_bytes, num_handles)) =
5548 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5549 {
5550 let member_inline_size =
5551 <ConnectionOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5552 if inlined != (member_inline_size <= 4) {
5553 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5554 }
5555 let inner_offset;
5556 let mut inner_depth = depth.clone();
5557 if inlined {
5558 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5559 inner_offset = next_offset;
5560 } else {
5561 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5562 inner_depth.increment()?;
5563 }
5564 let val_ref = self
5565 .connection_options
5566 .get_or_insert_with(|| fidl::new_empty!(ConnectionOptions, D));
5567 fidl::decode!(ConnectionOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
5568 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5569 {
5570 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5571 }
5572 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5573 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5574 }
5575 }
5576
5577 next_offset += envelope_size;
5578 _next_ordinal_to_read += 1;
5579 if next_offset >= end_offset {
5580 return Ok(());
5581 }
5582
5583 while _next_ordinal_to_read < 6 {
5585 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5586 _next_ordinal_to_read += 1;
5587 next_offset += envelope_size;
5588 }
5589
5590 let next_out_of_line = decoder.next_out_of_line();
5591 let handles_before = decoder.remaining_handles();
5592 if let Some((inlined, num_bytes, num_handles)) =
5593 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5594 {
5595 let member_inline_size =
5596 <AdvertisingProcedure as fidl::encoding::TypeMarker>::inline_size(
5597 decoder.context,
5598 );
5599 if inlined != (member_inline_size <= 4) {
5600 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5601 }
5602 let inner_offset;
5603 let mut inner_depth = depth.clone();
5604 if inlined {
5605 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5606 inner_offset = next_offset;
5607 } else {
5608 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5609 inner_depth.increment()?;
5610 }
5611 let val_ref = self
5612 .advertising_procedure
5613 .get_or_insert_with(|| fidl::new_empty!(AdvertisingProcedure, D));
5614 fidl::decode!(
5615 AdvertisingProcedure,
5616 D,
5617 val_ref,
5618 decoder,
5619 inner_offset,
5620 inner_depth
5621 )?;
5622 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5623 {
5624 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5625 }
5626 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5627 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5628 }
5629 }
5630
5631 next_offset += envelope_size;
5632 _next_ordinal_to_read += 1;
5633 if next_offset >= end_offset {
5634 return Ok(());
5635 }
5636
5637 while _next_ordinal_to_read < 7 {
5639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5640 _next_ordinal_to_read += 1;
5641 next_offset += envelope_size;
5642 }
5643
5644 let next_out_of_line = decoder.next_out_of_line();
5645 let handles_before = decoder.remaining_handles();
5646 if let Some((inlined, num_bytes, num_handles)) =
5647 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5648 {
5649 let member_inline_size = <fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5650 if inlined != (member_inline_size <= 4) {
5651 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5652 }
5653 let inner_offset;
5654 let mut inner_depth = depth.clone();
5655 if inlined {
5656 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5657 inner_offset = next_offset;
5658 } else {
5659 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5660 inner_depth.increment()?;
5661 }
5662 let val_ref = self.address_type.get_or_insert_with(|| {
5663 fidl::new_empty!(fidl_fuchsia_bluetooth__common::AddressType, D)
5664 });
5665 fidl::decode!(
5666 fidl_fuchsia_bluetooth__common::AddressType,
5667 D,
5668 val_ref,
5669 decoder,
5670 inner_offset,
5671 inner_depth
5672 )?;
5673 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5674 {
5675 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5676 }
5677 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5678 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5679 }
5680 }
5681
5682 next_offset += envelope_size;
5683
5684 while next_offset < end_offset {
5686 _next_ordinal_to_read += 1;
5687 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5688 next_offset += envelope_size;
5689 }
5690
5691 Ok(())
5692 }
5693 }
5694
5695 impl CentralCreateConnectedIsochronousGroupResponse {
5696 #[inline(always)]
5697 fn max_ordinal_present(&self) -> u64 {
5698 if let Some(_) = self.cig_id {
5699 return 1;
5700 }
5701 0
5702 }
5703 }
5704
5705 impl fidl::encoding::ValueTypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5706 type Borrowed<'a> = &'a Self;
5707 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5708 value
5709 }
5710 }
5711
5712 unsafe impl fidl::encoding::TypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5713 type Owned = Self;
5714
5715 #[inline(always)]
5716 fn inline_align(_context: fidl::encoding::Context) -> usize {
5717 8
5718 }
5719
5720 #[inline(always)]
5721 fn inline_size(_context: fidl::encoding::Context) -> usize {
5722 16
5723 }
5724 }
5725
5726 unsafe impl<D: fidl::encoding::ResourceDialect>
5727 fidl::encoding::Encode<CentralCreateConnectedIsochronousGroupResponse, D>
5728 for &CentralCreateConnectedIsochronousGroupResponse
5729 {
5730 unsafe fn encode(
5731 self,
5732 encoder: &mut fidl::encoding::Encoder<'_, D>,
5733 offset: usize,
5734 mut depth: fidl::encoding::Depth,
5735 ) -> fidl::Result<()> {
5736 encoder.debug_check_bounds::<CentralCreateConnectedIsochronousGroupResponse>(offset);
5737 let max_ordinal: u64 = self.max_ordinal_present();
5739 encoder.write_num(max_ordinal, offset);
5740 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5741 if max_ordinal == 0 {
5743 return Ok(());
5744 }
5745 depth.increment()?;
5746 let envelope_size = 8;
5747 let bytes_len = max_ordinal as usize * envelope_size;
5748 #[allow(unused_variables)]
5749 let offset = encoder.out_of_line_offset(bytes_len);
5750 let mut _prev_end_offset: usize = 0;
5751 if 1 > max_ordinal {
5752 return Ok(());
5753 }
5754
5755 let cur_offset: usize = (1 - 1) * envelope_size;
5758
5759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5761
5762 fidl::encoding::encode_in_envelope_optional::<u8, D>(
5767 self.cig_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5768 encoder,
5769 offset + cur_offset,
5770 depth,
5771 )?;
5772
5773 _prev_end_offset = cur_offset + envelope_size;
5774
5775 Ok(())
5776 }
5777 }
5778
5779 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5780 for CentralCreateConnectedIsochronousGroupResponse
5781 {
5782 #[inline(always)]
5783 fn new_empty() -> Self {
5784 Self::default()
5785 }
5786
5787 unsafe fn decode(
5788 &mut self,
5789 decoder: &mut fidl::encoding::Decoder<'_, D>,
5790 offset: usize,
5791 mut depth: fidl::encoding::Depth,
5792 ) -> fidl::Result<()> {
5793 decoder.debug_check_bounds::<Self>(offset);
5794 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5795 None => return Err(fidl::Error::NotNullable),
5796 Some(len) => len,
5797 };
5798 if len == 0 {
5800 return Ok(());
5801 };
5802 depth.increment()?;
5803 let envelope_size = 8;
5804 let bytes_len = len * envelope_size;
5805 let offset = decoder.out_of_line_offset(bytes_len)?;
5806 let mut _next_ordinal_to_read = 0;
5808 let mut next_offset = offset;
5809 let end_offset = offset + bytes_len;
5810 _next_ordinal_to_read += 1;
5811 if next_offset >= end_offset {
5812 return Ok(());
5813 }
5814
5815 while _next_ordinal_to_read < 1 {
5817 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5818 _next_ordinal_to_read += 1;
5819 next_offset += envelope_size;
5820 }
5821
5822 let next_out_of_line = decoder.next_out_of_line();
5823 let handles_before = decoder.remaining_handles();
5824 if let Some((inlined, num_bytes, num_handles)) =
5825 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5826 {
5827 let member_inline_size =
5828 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5829 if inlined != (member_inline_size <= 4) {
5830 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5831 }
5832 let inner_offset;
5833 let mut inner_depth = depth.clone();
5834 if inlined {
5835 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5836 inner_offset = next_offset;
5837 } else {
5838 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5839 inner_depth.increment()?;
5840 }
5841 let val_ref = self.cig_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
5842 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5843 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5844 {
5845 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5846 }
5847 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5848 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5849 }
5850 }
5851
5852 next_offset += envelope_size;
5853
5854 while next_offset < end_offset {
5856 _next_ordinal_to_read += 1;
5857 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5858 next_offset += envelope_size;
5859 }
5860
5861 Ok(())
5862 }
5863 }
5864
5865 impl ChannelListenerRegistryListenL2capResponse {
5866 #[inline(always)]
5867 fn max_ordinal_present(&self) -> u64 {
5868 if let Some(_) = self.psm {
5869 return 1;
5870 }
5871 0
5872 }
5873 }
5874
5875 impl fidl::encoding::ValueTypeMarker for ChannelListenerRegistryListenL2capResponse {
5876 type Borrowed<'a> = &'a Self;
5877 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5878 value
5879 }
5880 }
5881
5882 unsafe impl fidl::encoding::TypeMarker for ChannelListenerRegistryListenL2capResponse {
5883 type Owned = Self;
5884
5885 #[inline(always)]
5886 fn inline_align(_context: fidl::encoding::Context) -> usize {
5887 8
5888 }
5889
5890 #[inline(always)]
5891 fn inline_size(_context: fidl::encoding::Context) -> usize {
5892 16
5893 }
5894 }
5895
5896 unsafe impl<D: fidl::encoding::ResourceDialect>
5897 fidl::encoding::Encode<ChannelListenerRegistryListenL2capResponse, D>
5898 for &ChannelListenerRegistryListenL2capResponse
5899 {
5900 unsafe fn encode(
5901 self,
5902 encoder: &mut fidl::encoding::Encoder<'_, D>,
5903 offset: usize,
5904 mut depth: fidl::encoding::Depth,
5905 ) -> fidl::Result<()> {
5906 encoder.debug_check_bounds::<ChannelListenerRegistryListenL2capResponse>(offset);
5907 let max_ordinal: u64 = self.max_ordinal_present();
5909 encoder.write_num(max_ordinal, offset);
5910 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5911 if max_ordinal == 0 {
5913 return Ok(());
5914 }
5915 depth.increment()?;
5916 let envelope_size = 8;
5917 let bytes_len = max_ordinal as usize * envelope_size;
5918 #[allow(unused_variables)]
5919 let offset = encoder.out_of_line_offset(bytes_len);
5920 let mut _prev_end_offset: usize = 0;
5921 if 1 > max_ordinal {
5922 return Ok(());
5923 }
5924
5925 let cur_offset: usize = (1 - 1) * envelope_size;
5928
5929 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5931
5932 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5937 self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5938 encoder,
5939 offset + cur_offset,
5940 depth,
5941 )?;
5942
5943 _prev_end_offset = cur_offset + envelope_size;
5944
5945 Ok(())
5946 }
5947 }
5948
5949 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5950 for ChannelListenerRegistryListenL2capResponse
5951 {
5952 #[inline(always)]
5953 fn new_empty() -> Self {
5954 Self::default()
5955 }
5956
5957 unsafe fn decode(
5958 &mut self,
5959 decoder: &mut fidl::encoding::Decoder<'_, D>,
5960 offset: usize,
5961 mut depth: fidl::encoding::Depth,
5962 ) -> fidl::Result<()> {
5963 decoder.debug_check_bounds::<Self>(offset);
5964 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5965 None => return Err(fidl::Error::NotNullable),
5966 Some(len) => len,
5967 };
5968 if len == 0 {
5970 return Ok(());
5971 };
5972 depth.increment()?;
5973 let envelope_size = 8;
5974 let bytes_len = len * envelope_size;
5975 let offset = decoder.out_of_line_offset(bytes_len)?;
5976 let mut _next_ordinal_to_read = 0;
5978 let mut next_offset = offset;
5979 let end_offset = offset + bytes_len;
5980 _next_ordinal_to_read += 1;
5981 if next_offset >= end_offset {
5982 return Ok(());
5983 }
5984
5985 while _next_ordinal_to_read < 1 {
5987 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5988 _next_ordinal_to_read += 1;
5989 next_offset += envelope_size;
5990 }
5991
5992 let next_out_of_line = decoder.next_out_of_line();
5993 let handles_before = decoder.remaining_handles();
5994 if let Some((inlined, num_bytes, num_handles)) =
5995 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5996 {
5997 let member_inline_size =
5998 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5999 if inlined != (member_inline_size <= 4) {
6000 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6001 }
6002 let inner_offset;
6003 let mut inner_depth = depth.clone();
6004 if inlined {
6005 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6006 inner_offset = next_offset;
6007 } else {
6008 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6009 inner_depth.increment()?;
6010 }
6011 let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
6012 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6013 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6014 {
6015 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6016 }
6017 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6018 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6019 }
6020 }
6021
6022 next_offset += envelope_size;
6023
6024 while next_offset < end_offset {
6026 _next_ordinal_to_read += 1;
6027 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6028 next_offset += envelope_size;
6029 }
6030
6031 Ok(())
6032 }
6033 }
6034
6035 impl CigParameters {
6036 #[inline(always)]
6037 fn max_ordinal_present(&self) -> u64 {
6038 if let Some(_) = self.max_transport_latency_p_to_c {
6039 return 6;
6040 }
6041 if let Some(_) = self.max_transport_latency_c_to_p {
6042 return 5;
6043 }
6044 if let Some(_) = self.framing {
6045 return 4;
6046 }
6047 if let Some(_) = self.packing {
6048 return 3;
6049 }
6050 if let Some(_) = self.sdu_interval_p_to_c {
6051 return 2;
6052 }
6053 if let Some(_) = self.sdu_interval_c_to_p {
6054 return 1;
6055 }
6056 0
6057 }
6058 }
6059
6060 impl fidl::encoding::ValueTypeMarker for CigParameters {
6061 type Borrowed<'a> = &'a Self;
6062 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6063 value
6064 }
6065 }
6066
6067 unsafe impl fidl::encoding::TypeMarker for CigParameters {
6068 type Owned = Self;
6069
6070 #[inline(always)]
6071 fn inline_align(_context: fidl::encoding::Context) -> usize {
6072 8
6073 }
6074
6075 #[inline(always)]
6076 fn inline_size(_context: fidl::encoding::Context) -> usize {
6077 16
6078 }
6079 }
6080
6081 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CigParameters, D>
6082 for &CigParameters
6083 {
6084 unsafe fn encode(
6085 self,
6086 encoder: &mut fidl::encoding::Encoder<'_, D>,
6087 offset: usize,
6088 mut depth: fidl::encoding::Depth,
6089 ) -> fidl::Result<()> {
6090 encoder.debug_check_bounds::<CigParameters>(offset);
6091 let max_ordinal: u64 = self.max_ordinal_present();
6093 encoder.write_num(max_ordinal, offset);
6094 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6095 if max_ordinal == 0 {
6097 return Ok(());
6098 }
6099 depth.increment()?;
6100 let envelope_size = 8;
6101 let bytes_len = max_ordinal as usize * envelope_size;
6102 #[allow(unused_variables)]
6103 let offset = encoder.out_of_line_offset(bytes_len);
6104 let mut _prev_end_offset: usize = 0;
6105 if 1 > max_ordinal {
6106 return Ok(());
6107 }
6108
6109 let cur_offset: usize = (1 - 1) * envelope_size;
6112
6113 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6115
6116 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6121 self.sdu_interval_c_to_p
6122 .as_ref()
6123 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6124 encoder,
6125 offset + cur_offset,
6126 depth,
6127 )?;
6128
6129 _prev_end_offset = cur_offset + envelope_size;
6130 if 2 > max_ordinal {
6131 return Ok(());
6132 }
6133
6134 let cur_offset: usize = (2 - 1) * envelope_size;
6137
6138 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6140
6141 fidl::encoding::encode_in_envelope_optional::<u32, D>(
6146 self.sdu_interval_p_to_c
6147 .as_ref()
6148 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6149 encoder,
6150 offset + cur_offset,
6151 depth,
6152 )?;
6153
6154 _prev_end_offset = cur_offset + envelope_size;
6155 if 3 > max_ordinal {
6156 return Ok(());
6157 }
6158
6159 let cur_offset: usize = (3 - 1) * envelope_size;
6162
6163 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6165
6166 fidl::encoding::encode_in_envelope_optional::<CigPacking, D>(
6171 self.packing.as_ref().map(<CigPacking as fidl::encoding::ValueTypeMarker>::borrow),
6172 encoder,
6173 offset + cur_offset,
6174 depth,
6175 )?;
6176
6177 _prev_end_offset = cur_offset + envelope_size;
6178 if 4 > max_ordinal {
6179 return Ok(());
6180 }
6181
6182 let cur_offset: usize = (4 - 1) * envelope_size;
6185
6186 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6188
6189 fidl::encoding::encode_in_envelope_optional::<CigFramingOptions, D>(
6194 self.framing
6195 .as_ref()
6196 .map(<CigFramingOptions as fidl::encoding::ValueTypeMarker>::borrow),
6197 encoder,
6198 offset + cur_offset,
6199 depth,
6200 )?;
6201
6202 _prev_end_offset = cur_offset + envelope_size;
6203 if 5 > max_ordinal {
6204 return Ok(());
6205 }
6206
6207 let cur_offset: usize = (5 - 1) * envelope_size;
6210
6211 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6213
6214 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6219 self.max_transport_latency_c_to_p
6220 .as_ref()
6221 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6222 encoder,
6223 offset + cur_offset,
6224 depth,
6225 )?;
6226
6227 _prev_end_offset = cur_offset + envelope_size;
6228 if 6 > max_ordinal {
6229 return Ok(());
6230 }
6231
6232 let cur_offset: usize = (6 - 1) * envelope_size;
6235
6236 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6238
6239 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6244 self.max_transport_latency_p_to_c
6245 .as_ref()
6246 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6247 encoder,
6248 offset + cur_offset,
6249 depth,
6250 )?;
6251
6252 _prev_end_offset = cur_offset + envelope_size;
6253
6254 Ok(())
6255 }
6256 }
6257
6258 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigParameters {
6259 #[inline(always)]
6260 fn new_empty() -> Self {
6261 Self::default()
6262 }
6263
6264 unsafe fn decode(
6265 &mut self,
6266 decoder: &mut fidl::encoding::Decoder<'_, D>,
6267 offset: usize,
6268 mut depth: fidl::encoding::Depth,
6269 ) -> fidl::Result<()> {
6270 decoder.debug_check_bounds::<Self>(offset);
6271 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6272 None => return Err(fidl::Error::NotNullable),
6273 Some(len) => len,
6274 };
6275 if len == 0 {
6277 return Ok(());
6278 };
6279 depth.increment()?;
6280 let envelope_size = 8;
6281 let bytes_len = len * envelope_size;
6282 let offset = decoder.out_of_line_offset(bytes_len)?;
6283 let mut _next_ordinal_to_read = 0;
6285 let mut next_offset = offset;
6286 let end_offset = offset + bytes_len;
6287 _next_ordinal_to_read += 1;
6288 if next_offset >= end_offset {
6289 return Ok(());
6290 }
6291
6292 while _next_ordinal_to_read < 1 {
6294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6295 _next_ordinal_to_read += 1;
6296 next_offset += envelope_size;
6297 }
6298
6299 let next_out_of_line = decoder.next_out_of_line();
6300 let handles_before = decoder.remaining_handles();
6301 if let Some((inlined, num_bytes, num_handles)) =
6302 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6303 {
6304 let member_inline_size =
6305 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6306 if inlined != (member_inline_size <= 4) {
6307 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6308 }
6309 let inner_offset;
6310 let mut inner_depth = depth.clone();
6311 if inlined {
6312 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6313 inner_offset = next_offset;
6314 } else {
6315 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6316 inner_depth.increment()?;
6317 }
6318 let val_ref =
6319 self.sdu_interval_c_to_p.get_or_insert_with(|| fidl::new_empty!(u32, D));
6320 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6321 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6322 {
6323 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6324 }
6325 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6326 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6327 }
6328 }
6329
6330 next_offset += envelope_size;
6331 _next_ordinal_to_read += 1;
6332 if next_offset >= end_offset {
6333 return Ok(());
6334 }
6335
6336 while _next_ordinal_to_read < 2 {
6338 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6339 _next_ordinal_to_read += 1;
6340 next_offset += envelope_size;
6341 }
6342
6343 let next_out_of_line = decoder.next_out_of_line();
6344 let handles_before = decoder.remaining_handles();
6345 if let Some((inlined, num_bytes, num_handles)) =
6346 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6347 {
6348 let member_inline_size =
6349 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6350 if inlined != (member_inline_size <= 4) {
6351 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6352 }
6353 let inner_offset;
6354 let mut inner_depth = depth.clone();
6355 if inlined {
6356 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6357 inner_offset = next_offset;
6358 } else {
6359 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6360 inner_depth.increment()?;
6361 }
6362 let val_ref =
6363 self.sdu_interval_p_to_c.get_or_insert_with(|| fidl::new_empty!(u32, D));
6364 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6365 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6366 {
6367 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6368 }
6369 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6370 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6371 }
6372 }
6373
6374 next_offset += envelope_size;
6375 _next_ordinal_to_read += 1;
6376 if next_offset >= end_offset {
6377 return Ok(());
6378 }
6379
6380 while _next_ordinal_to_read < 3 {
6382 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6383 _next_ordinal_to_read += 1;
6384 next_offset += envelope_size;
6385 }
6386
6387 let next_out_of_line = decoder.next_out_of_line();
6388 let handles_before = decoder.remaining_handles();
6389 if let Some((inlined, num_bytes, num_handles)) =
6390 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6391 {
6392 let member_inline_size =
6393 <CigPacking as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6394 if inlined != (member_inline_size <= 4) {
6395 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6396 }
6397 let inner_offset;
6398 let mut inner_depth = depth.clone();
6399 if inlined {
6400 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6401 inner_offset = next_offset;
6402 } else {
6403 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6404 inner_depth.increment()?;
6405 }
6406 let val_ref = self.packing.get_or_insert_with(|| fidl::new_empty!(CigPacking, D));
6407 fidl::decode!(CigPacking, D, val_ref, decoder, inner_offset, inner_depth)?;
6408 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6409 {
6410 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6411 }
6412 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6413 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6414 }
6415 }
6416
6417 next_offset += envelope_size;
6418 _next_ordinal_to_read += 1;
6419 if next_offset >= end_offset {
6420 return Ok(());
6421 }
6422
6423 while _next_ordinal_to_read < 4 {
6425 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6426 _next_ordinal_to_read += 1;
6427 next_offset += envelope_size;
6428 }
6429
6430 let next_out_of_line = decoder.next_out_of_line();
6431 let handles_before = decoder.remaining_handles();
6432 if let Some((inlined, num_bytes, num_handles)) =
6433 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6434 {
6435 let member_inline_size =
6436 <CigFramingOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6437 if inlined != (member_inline_size <= 4) {
6438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6439 }
6440 let inner_offset;
6441 let mut inner_depth = depth.clone();
6442 if inlined {
6443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6444 inner_offset = next_offset;
6445 } else {
6446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6447 inner_depth.increment()?;
6448 }
6449 let val_ref =
6450 self.framing.get_or_insert_with(|| fidl::new_empty!(CigFramingOptions, D));
6451 fidl::decode!(CigFramingOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
6452 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6453 {
6454 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6455 }
6456 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6457 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6458 }
6459 }
6460
6461 next_offset += envelope_size;
6462 _next_ordinal_to_read += 1;
6463 if next_offset >= end_offset {
6464 return Ok(());
6465 }
6466
6467 while _next_ordinal_to_read < 5 {
6469 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6470 _next_ordinal_to_read += 1;
6471 next_offset += envelope_size;
6472 }
6473
6474 let next_out_of_line = decoder.next_out_of_line();
6475 let handles_before = decoder.remaining_handles();
6476 if let Some((inlined, num_bytes, num_handles)) =
6477 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6478 {
6479 let member_inline_size =
6480 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6481 if inlined != (member_inline_size <= 4) {
6482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6483 }
6484 let inner_offset;
6485 let mut inner_depth = depth.clone();
6486 if inlined {
6487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6488 inner_offset = next_offset;
6489 } else {
6490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6491 inner_depth.increment()?;
6492 }
6493 let val_ref = self
6494 .max_transport_latency_c_to_p
6495 .get_or_insert_with(|| fidl::new_empty!(u16, D));
6496 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6497 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6498 {
6499 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6500 }
6501 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6502 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6503 }
6504 }
6505
6506 next_offset += envelope_size;
6507 _next_ordinal_to_read += 1;
6508 if next_offset >= end_offset {
6509 return Ok(());
6510 }
6511
6512 while _next_ordinal_to_read < 6 {
6514 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6515 _next_ordinal_to_read += 1;
6516 next_offset += envelope_size;
6517 }
6518
6519 let next_out_of_line = decoder.next_out_of_line();
6520 let handles_before = decoder.remaining_handles();
6521 if let Some((inlined, num_bytes, num_handles)) =
6522 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6523 {
6524 let member_inline_size =
6525 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6526 if inlined != (member_inline_size <= 4) {
6527 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6528 }
6529 let inner_offset;
6530 let mut inner_depth = depth.clone();
6531 if inlined {
6532 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6533 inner_offset = next_offset;
6534 } else {
6535 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6536 inner_depth.increment()?;
6537 }
6538 let val_ref = self
6539 .max_transport_latency_p_to_c
6540 .get_or_insert_with(|| fidl::new_empty!(u16, D));
6541 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6542 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6543 {
6544 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6545 }
6546 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6547 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6548 }
6549 }
6550
6551 next_offset += envelope_size;
6552
6553 while next_offset < end_offset {
6555 _next_ordinal_to_read += 1;
6556 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6557 next_offset += envelope_size;
6558 }
6559
6560 Ok(())
6561 }
6562 }
6563
6564 impl CisEstablishedParameters {
6565 #[inline(always)]
6566 fn max_ordinal_present(&self) -> u64 {
6567 if let Some(_) = self.peripheral_to_central_params {
6568 return 6;
6569 }
6570 if let Some(_) = self.central_to_peripheral_params {
6571 return 5;
6572 }
6573 if let Some(_) = self.iso_interval {
6574 return 4;
6575 }
6576 if let Some(_) = self.max_subevents {
6577 return 3;
6578 }
6579 if let Some(_) = self.cis_sync_delay {
6580 return 2;
6581 }
6582 if let Some(_) = self.cig_sync_delay {
6583 return 1;
6584 }
6585 0
6586 }
6587 }
6588
6589 impl fidl::encoding::ValueTypeMarker for CisEstablishedParameters {
6590 type Borrowed<'a> = &'a Self;
6591 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6592 value
6593 }
6594 }
6595
6596 unsafe impl fidl::encoding::TypeMarker for CisEstablishedParameters {
6597 type Owned = Self;
6598
6599 #[inline(always)]
6600 fn inline_align(_context: fidl::encoding::Context) -> usize {
6601 8
6602 }
6603
6604 #[inline(always)]
6605 fn inline_size(_context: fidl::encoding::Context) -> usize {
6606 16
6607 }
6608 }
6609
6610 unsafe impl<D: fidl::encoding::ResourceDialect>
6611 fidl::encoding::Encode<CisEstablishedParameters, D> for &CisEstablishedParameters
6612 {
6613 unsafe fn encode(
6614 self,
6615 encoder: &mut fidl::encoding::Encoder<'_, D>,
6616 offset: usize,
6617 mut depth: fidl::encoding::Depth,
6618 ) -> fidl::Result<()> {
6619 encoder.debug_check_bounds::<CisEstablishedParameters>(offset);
6620 let max_ordinal: u64 = self.max_ordinal_present();
6622 encoder.write_num(max_ordinal, offset);
6623 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6624 if max_ordinal == 0 {
6626 return Ok(());
6627 }
6628 depth.increment()?;
6629 let envelope_size = 8;
6630 let bytes_len = max_ordinal as usize * envelope_size;
6631 #[allow(unused_variables)]
6632 let offset = encoder.out_of_line_offset(bytes_len);
6633 let mut _prev_end_offset: usize = 0;
6634 if 1 > max_ordinal {
6635 return Ok(());
6636 }
6637
6638 let cur_offset: usize = (1 - 1) * envelope_size;
6641
6642 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6644
6645 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6650 self.cig_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6651 encoder,
6652 offset + cur_offset,
6653 depth,
6654 )?;
6655
6656 _prev_end_offset = cur_offset + envelope_size;
6657 if 2 > max_ordinal {
6658 return Ok(());
6659 }
6660
6661 let cur_offset: usize = (2 - 1) * envelope_size;
6664
6665 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6667
6668 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6673 self.cis_sync_delay.as_ref().map(<i64 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 3 > max_ordinal {
6681 return Ok(());
6682 }
6683
6684 let cur_offset: usize = (3 - 1) * envelope_size;
6687
6688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6690
6691 fidl::encoding::encode_in_envelope_optional::<u8, D>(
6696 self.max_subevents.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
6697 encoder,
6698 offset + cur_offset,
6699 depth,
6700 )?;
6701
6702 _prev_end_offset = cur_offset + envelope_size;
6703 if 4 > max_ordinal {
6704 return Ok(());
6705 }
6706
6707 let cur_offset: usize = (4 - 1) * envelope_size;
6710
6711 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6713
6714 fidl::encoding::encode_in_envelope_optional::<i64, D>(
6719 self.iso_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6720 encoder,
6721 offset + cur_offset,
6722 depth,
6723 )?;
6724
6725 _prev_end_offset = cur_offset + envelope_size;
6726 if 5 > max_ordinal {
6727 return Ok(());
6728 }
6729
6730 let cur_offset: usize = (5 - 1) * envelope_size;
6733
6734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6736
6737 fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6742 self.central_to_peripheral_params
6743 .as_ref()
6744 .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6745 encoder,
6746 offset + cur_offset,
6747 depth,
6748 )?;
6749
6750 _prev_end_offset = cur_offset + envelope_size;
6751 if 6 > max_ordinal {
6752 return Ok(());
6753 }
6754
6755 let cur_offset: usize = (6 - 1) * envelope_size;
6758
6759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6761
6762 fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6767 self.peripheral_to_central_params
6768 .as_ref()
6769 .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6770 encoder,
6771 offset + cur_offset,
6772 depth,
6773 )?;
6774
6775 _prev_end_offset = cur_offset + envelope_size;
6776
6777 Ok(())
6778 }
6779 }
6780
6781 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6782 for CisEstablishedParameters
6783 {
6784 #[inline(always)]
6785 fn new_empty() -> Self {
6786 Self::default()
6787 }
6788
6789 unsafe fn decode(
6790 &mut self,
6791 decoder: &mut fidl::encoding::Decoder<'_, D>,
6792 offset: usize,
6793 mut depth: fidl::encoding::Depth,
6794 ) -> fidl::Result<()> {
6795 decoder.debug_check_bounds::<Self>(offset);
6796 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6797 None => return Err(fidl::Error::NotNullable),
6798 Some(len) => len,
6799 };
6800 if len == 0 {
6802 return Ok(());
6803 };
6804 depth.increment()?;
6805 let envelope_size = 8;
6806 let bytes_len = len * envelope_size;
6807 let offset = decoder.out_of_line_offset(bytes_len)?;
6808 let mut _next_ordinal_to_read = 0;
6810 let mut next_offset = offset;
6811 let end_offset = offset + bytes_len;
6812 _next_ordinal_to_read += 1;
6813 if next_offset >= end_offset {
6814 return Ok(());
6815 }
6816
6817 while _next_ordinal_to_read < 1 {
6819 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6820 _next_ordinal_to_read += 1;
6821 next_offset += envelope_size;
6822 }
6823
6824 let next_out_of_line = decoder.next_out_of_line();
6825 let handles_before = decoder.remaining_handles();
6826 if let Some((inlined, num_bytes, num_handles)) =
6827 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6828 {
6829 let member_inline_size =
6830 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6831 if inlined != (member_inline_size <= 4) {
6832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6833 }
6834 let inner_offset;
6835 let mut inner_depth = depth.clone();
6836 if inlined {
6837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6838 inner_offset = next_offset;
6839 } else {
6840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6841 inner_depth.increment()?;
6842 }
6843 let val_ref = self.cig_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6844 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6845 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6846 {
6847 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6848 }
6849 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6850 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6851 }
6852 }
6853
6854 next_offset += envelope_size;
6855 _next_ordinal_to_read += 1;
6856 if next_offset >= end_offset {
6857 return Ok(());
6858 }
6859
6860 while _next_ordinal_to_read < 2 {
6862 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6863 _next_ordinal_to_read += 1;
6864 next_offset += envelope_size;
6865 }
6866
6867 let next_out_of_line = decoder.next_out_of_line();
6868 let handles_before = decoder.remaining_handles();
6869 if let Some((inlined, num_bytes, num_handles)) =
6870 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6871 {
6872 let member_inline_size =
6873 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6874 if inlined != (member_inline_size <= 4) {
6875 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6876 }
6877 let inner_offset;
6878 let mut inner_depth = depth.clone();
6879 if inlined {
6880 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6881 inner_offset = next_offset;
6882 } else {
6883 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6884 inner_depth.increment()?;
6885 }
6886 let val_ref = self.cis_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6887 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6888 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6889 {
6890 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6891 }
6892 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6893 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6894 }
6895 }
6896
6897 next_offset += envelope_size;
6898 _next_ordinal_to_read += 1;
6899 if next_offset >= end_offset {
6900 return Ok(());
6901 }
6902
6903 while _next_ordinal_to_read < 3 {
6905 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6906 _next_ordinal_to_read += 1;
6907 next_offset += envelope_size;
6908 }
6909
6910 let next_out_of_line = decoder.next_out_of_line();
6911 let handles_before = decoder.remaining_handles();
6912 if let Some((inlined, num_bytes, num_handles)) =
6913 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6914 {
6915 let member_inline_size =
6916 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6917 if inlined != (member_inline_size <= 4) {
6918 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6919 }
6920 let inner_offset;
6921 let mut inner_depth = depth.clone();
6922 if inlined {
6923 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6924 inner_offset = next_offset;
6925 } else {
6926 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6927 inner_depth.increment()?;
6928 }
6929 let val_ref = self.max_subevents.get_or_insert_with(|| fidl::new_empty!(u8, D));
6930 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6931 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6932 {
6933 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6934 }
6935 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6936 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6937 }
6938 }
6939
6940 next_offset += envelope_size;
6941 _next_ordinal_to_read += 1;
6942 if next_offset >= end_offset {
6943 return Ok(());
6944 }
6945
6946 while _next_ordinal_to_read < 4 {
6948 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6949 _next_ordinal_to_read += 1;
6950 next_offset += envelope_size;
6951 }
6952
6953 let next_out_of_line = decoder.next_out_of_line();
6954 let handles_before = decoder.remaining_handles();
6955 if let Some((inlined, num_bytes, num_handles)) =
6956 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6957 {
6958 let member_inline_size =
6959 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6960 if inlined != (member_inline_size <= 4) {
6961 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6962 }
6963 let inner_offset;
6964 let mut inner_depth = depth.clone();
6965 if inlined {
6966 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6967 inner_offset = next_offset;
6968 } else {
6969 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6970 inner_depth.increment()?;
6971 }
6972 let val_ref = self.iso_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
6973 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6974 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6975 {
6976 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6977 }
6978 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6979 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6980 }
6981 }
6982
6983 next_offset += envelope_size;
6984 _next_ordinal_to_read += 1;
6985 if next_offset >= end_offset {
6986 return Ok(());
6987 }
6988
6989 while _next_ordinal_to_read < 5 {
6991 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6992 _next_ordinal_to_read += 1;
6993 next_offset += envelope_size;
6994 }
6995
6996 let next_out_of_line = decoder.next_out_of_line();
6997 let handles_before = decoder.remaining_handles();
6998 if let Some((inlined, num_bytes, num_handles)) =
6999 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7000 {
7001 let member_inline_size =
7002 <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
7003 decoder.context,
7004 );
7005 if inlined != (member_inline_size <= 4) {
7006 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7007 }
7008 let inner_offset;
7009 let mut inner_depth = depth.clone();
7010 if inlined {
7011 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7012 inner_offset = next_offset;
7013 } else {
7014 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7015 inner_depth.increment()?;
7016 }
7017 let val_ref = self
7018 .central_to_peripheral_params
7019 .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7020 fidl::decode!(
7021 CisUnidirectionalParams,
7022 D,
7023 val_ref,
7024 decoder,
7025 inner_offset,
7026 inner_depth
7027 )?;
7028 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7029 {
7030 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7031 }
7032 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7033 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7034 }
7035 }
7036
7037 next_offset += envelope_size;
7038 _next_ordinal_to_read += 1;
7039 if next_offset >= end_offset {
7040 return Ok(());
7041 }
7042
7043 while _next_ordinal_to_read < 6 {
7045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7046 _next_ordinal_to_read += 1;
7047 next_offset += envelope_size;
7048 }
7049
7050 let next_out_of_line = decoder.next_out_of_line();
7051 let handles_before = decoder.remaining_handles();
7052 if let Some((inlined, num_bytes, num_handles)) =
7053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7054 {
7055 let member_inline_size =
7056 <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
7057 decoder.context,
7058 );
7059 if inlined != (member_inline_size <= 4) {
7060 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7061 }
7062 let inner_offset;
7063 let mut inner_depth = depth.clone();
7064 if inlined {
7065 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7066 inner_offset = next_offset;
7067 } else {
7068 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7069 inner_depth.increment()?;
7070 }
7071 let val_ref = self
7072 .peripheral_to_central_params
7073 .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7074 fidl::decode!(
7075 CisUnidirectionalParams,
7076 D,
7077 val_ref,
7078 decoder,
7079 inner_offset,
7080 inner_depth
7081 )?;
7082 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7083 {
7084 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7085 }
7086 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7087 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7088 }
7089 }
7090
7091 next_offset += envelope_size;
7092
7093 while next_offset < end_offset {
7095 _next_ordinal_to_read += 1;
7096 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7097 next_offset += envelope_size;
7098 }
7099
7100 Ok(())
7101 }
7102 }
7103
7104 impl CisParameters {
7105 #[inline(always)]
7106 fn max_ordinal_present(&self) -> u64 {
7107 if let Some(_) = self.id {
7108 return 2;
7109 }
7110 if let Some(_) = self.cis_id {
7111 return 1;
7112 }
7113 0
7114 }
7115 }
7116
7117 impl fidl::encoding::ValueTypeMarker for CisParameters {
7118 type Borrowed<'a> = &'a Self;
7119 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7120 value
7121 }
7122 }
7123
7124 unsafe impl fidl::encoding::TypeMarker for CisParameters {
7125 type Owned = Self;
7126
7127 #[inline(always)]
7128 fn inline_align(_context: fidl::encoding::Context) -> usize {
7129 8
7130 }
7131
7132 #[inline(always)]
7133 fn inline_size(_context: fidl::encoding::Context) -> usize {
7134 16
7135 }
7136 }
7137
7138 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CisParameters, D>
7139 for &CisParameters
7140 {
7141 unsafe fn encode(
7142 self,
7143 encoder: &mut fidl::encoding::Encoder<'_, D>,
7144 offset: usize,
7145 mut depth: fidl::encoding::Depth,
7146 ) -> fidl::Result<()> {
7147 encoder.debug_check_bounds::<CisParameters>(offset);
7148 let max_ordinal: u64 = self.max_ordinal_present();
7150 encoder.write_num(max_ordinal, offset);
7151 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7152 if max_ordinal == 0 {
7154 return Ok(());
7155 }
7156 depth.increment()?;
7157 let envelope_size = 8;
7158 let bytes_len = max_ordinal as usize * envelope_size;
7159 #[allow(unused_variables)]
7160 let offset = encoder.out_of_line_offset(bytes_len);
7161 let mut _prev_end_offset: usize = 0;
7162 if 1 > max_ordinal {
7163 return Ok(());
7164 }
7165
7166 let cur_offset: usize = (1 - 1) * envelope_size;
7169
7170 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7172
7173 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7178 self.cis_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7179 encoder,
7180 offset + cur_offset,
7181 depth,
7182 )?;
7183
7184 _prev_end_offset = cur_offset + envelope_size;
7185 if 2 > max_ordinal {
7186 return Ok(());
7187 }
7188
7189 let cur_offset: usize = (2 - 1) * envelope_size;
7192
7193 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7195
7196 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
7201 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
7202 encoder, offset + cur_offset, depth
7203 )?;
7204
7205 _prev_end_offset = cur_offset + envelope_size;
7206
7207 Ok(())
7208 }
7209 }
7210
7211 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CisParameters {
7212 #[inline(always)]
7213 fn new_empty() -> Self {
7214 Self::default()
7215 }
7216
7217 unsafe fn decode(
7218 &mut self,
7219 decoder: &mut fidl::encoding::Decoder<'_, D>,
7220 offset: usize,
7221 mut depth: fidl::encoding::Depth,
7222 ) -> fidl::Result<()> {
7223 decoder.debug_check_bounds::<Self>(offset);
7224 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7225 None => return Err(fidl::Error::NotNullable),
7226 Some(len) => len,
7227 };
7228 if len == 0 {
7230 return Ok(());
7231 };
7232 depth.increment()?;
7233 let envelope_size = 8;
7234 let bytes_len = len * envelope_size;
7235 let offset = decoder.out_of_line_offset(bytes_len)?;
7236 let mut _next_ordinal_to_read = 0;
7238 let mut next_offset = offset;
7239 let end_offset = offset + bytes_len;
7240 _next_ordinal_to_read += 1;
7241 if next_offset >= end_offset {
7242 return Ok(());
7243 }
7244
7245 while _next_ordinal_to_read < 1 {
7247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7248 _next_ordinal_to_read += 1;
7249 next_offset += envelope_size;
7250 }
7251
7252 let next_out_of_line = decoder.next_out_of_line();
7253 let handles_before = decoder.remaining_handles();
7254 if let Some((inlined, num_bytes, num_handles)) =
7255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7256 {
7257 let member_inline_size =
7258 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7259 if inlined != (member_inline_size <= 4) {
7260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7261 }
7262 let inner_offset;
7263 let mut inner_depth = depth.clone();
7264 if inlined {
7265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7266 inner_offset = next_offset;
7267 } else {
7268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7269 inner_depth.increment()?;
7270 }
7271 let val_ref = self.cis_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7272 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7274 {
7275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7276 }
7277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7279 }
7280 }
7281
7282 next_offset += envelope_size;
7283 _next_ordinal_to_read += 1;
7284 if next_offset >= end_offset {
7285 return Ok(());
7286 }
7287
7288 while _next_ordinal_to_read < 2 {
7290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7291 _next_ordinal_to_read += 1;
7292 next_offset += envelope_size;
7293 }
7294
7295 let next_out_of_line = decoder.next_out_of_line();
7296 let handles_before = decoder.remaining_handles();
7297 if let Some((inlined, num_bytes, num_handles)) =
7298 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7299 {
7300 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7301 if inlined != (member_inline_size <= 4) {
7302 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7303 }
7304 let inner_offset;
7305 let mut inner_depth = depth.clone();
7306 if inlined {
7307 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7308 inner_offset = next_offset;
7309 } else {
7310 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7311 inner_depth.increment()?;
7312 }
7313 let val_ref = self.id.get_or_insert_with(|| {
7314 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
7315 });
7316 fidl::decode!(
7317 fidl_fuchsia_bluetooth__common::PeerId,
7318 D,
7319 val_ref,
7320 decoder,
7321 inner_offset,
7322 inner_depth
7323 )?;
7324 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7325 {
7326 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7327 }
7328 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7329 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7330 }
7331 }
7332
7333 next_offset += envelope_size;
7334
7335 while next_offset < end_offset {
7337 _next_ordinal_to_read += 1;
7338 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7339 next_offset += envelope_size;
7340 }
7341
7342 Ok(())
7343 }
7344 }
7345
7346 impl CisUnidirectionalParams {
7347 #[inline(always)]
7348 fn max_ordinal_present(&self) -> u64 {
7349 if let Some(_) = self.flush_timeout {
7350 return 3;
7351 }
7352 if let Some(_) = self.burst_number {
7353 return 2;
7354 }
7355 if let Some(_) = self.transport_latency {
7356 return 1;
7357 }
7358 0
7359 }
7360 }
7361
7362 impl fidl::encoding::ValueTypeMarker for CisUnidirectionalParams {
7363 type Borrowed<'a> = &'a Self;
7364 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7365 value
7366 }
7367 }
7368
7369 unsafe impl fidl::encoding::TypeMarker for CisUnidirectionalParams {
7370 type Owned = Self;
7371
7372 #[inline(always)]
7373 fn inline_align(_context: fidl::encoding::Context) -> usize {
7374 8
7375 }
7376
7377 #[inline(always)]
7378 fn inline_size(_context: fidl::encoding::Context) -> usize {
7379 16
7380 }
7381 }
7382
7383 unsafe impl<D: fidl::encoding::ResourceDialect>
7384 fidl::encoding::Encode<CisUnidirectionalParams, D> for &CisUnidirectionalParams
7385 {
7386 unsafe fn encode(
7387 self,
7388 encoder: &mut fidl::encoding::Encoder<'_, D>,
7389 offset: usize,
7390 mut depth: fidl::encoding::Depth,
7391 ) -> fidl::Result<()> {
7392 encoder.debug_check_bounds::<CisUnidirectionalParams>(offset);
7393 let max_ordinal: u64 = self.max_ordinal_present();
7395 encoder.write_num(max_ordinal, offset);
7396 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7397 if max_ordinal == 0 {
7399 return Ok(());
7400 }
7401 depth.increment()?;
7402 let envelope_size = 8;
7403 let bytes_len = max_ordinal as usize * envelope_size;
7404 #[allow(unused_variables)]
7405 let offset = encoder.out_of_line_offset(bytes_len);
7406 let mut _prev_end_offset: usize = 0;
7407 if 1 > max_ordinal {
7408 return Ok(());
7409 }
7410
7411 let cur_offset: usize = (1 - 1) * envelope_size;
7414
7415 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7417
7418 fidl::encoding::encode_in_envelope_optional::<i64, D>(
7423 self.transport_latency
7424 .as_ref()
7425 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7426 encoder,
7427 offset + cur_offset,
7428 depth,
7429 )?;
7430
7431 _prev_end_offset = cur_offset + envelope_size;
7432 if 2 > max_ordinal {
7433 return Ok(());
7434 }
7435
7436 let cur_offset: usize = (2 - 1) * envelope_size;
7439
7440 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7442
7443 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7448 self.burst_number.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7449 encoder,
7450 offset + cur_offset,
7451 depth,
7452 )?;
7453
7454 _prev_end_offset = cur_offset + envelope_size;
7455 if 3 > max_ordinal {
7456 return Ok(());
7457 }
7458
7459 let cur_offset: usize = (3 - 1) * envelope_size;
7462
7463 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7465
7466 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7471 self.flush_timeout.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7472 encoder,
7473 offset + cur_offset,
7474 depth,
7475 )?;
7476
7477 _prev_end_offset = cur_offset + envelope_size;
7478
7479 Ok(())
7480 }
7481 }
7482
7483 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7484 for CisUnidirectionalParams
7485 {
7486 #[inline(always)]
7487 fn new_empty() -> Self {
7488 Self::default()
7489 }
7490
7491 unsafe fn decode(
7492 &mut self,
7493 decoder: &mut fidl::encoding::Decoder<'_, D>,
7494 offset: usize,
7495 mut depth: fidl::encoding::Depth,
7496 ) -> fidl::Result<()> {
7497 decoder.debug_check_bounds::<Self>(offset);
7498 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7499 None => return Err(fidl::Error::NotNullable),
7500 Some(len) => len,
7501 };
7502 if len == 0 {
7504 return Ok(());
7505 };
7506 depth.increment()?;
7507 let envelope_size = 8;
7508 let bytes_len = len * envelope_size;
7509 let offset = decoder.out_of_line_offset(bytes_len)?;
7510 let mut _next_ordinal_to_read = 0;
7512 let mut next_offset = offset;
7513 let end_offset = offset + bytes_len;
7514 _next_ordinal_to_read += 1;
7515 if next_offset >= end_offset {
7516 return Ok(());
7517 }
7518
7519 while _next_ordinal_to_read < 1 {
7521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7522 _next_ordinal_to_read += 1;
7523 next_offset += envelope_size;
7524 }
7525
7526 let next_out_of_line = decoder.next_out_of_line();
7527 let handles_before = decoder.remaining_handles();
7528 if let Some((inlined, num_bytes, num_handles)) =
7529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7530 {
7531 let member_inline_size =
7532 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7533 if inlined != (member_inline_size <= 4) {
7534 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7535 }
7536 let inner_offset;
7537 let mut inner_depth = depth.clone();
7538 if inlined {
7539 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7540 inner_offset = next_offset;
7541 } else {
7542 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7543 inner_depth.increment()?;
7544 }
7545 let val_ref =
7546 self.transport_latency.get_or_insert_with(|| fidl::new_empty!(i64, D));
7547 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7548 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7549 {
7550 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7551 }
7552 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7553 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7554 }
7555 }
7556
7557 next_offset += envelope_size;
7558 _next_ordinal_to_read += 1;
7559 if next_offset >= end_offset {
7560 return Ok(());
7561 }
7562
7563 while _next_ordinal_to_read < 2 {
7565 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7566 _next_ordinal_to_read += 1;
7567 next_offset += envelope_size;
7568 }
7569
7570 let next_out_of_line = decoder.next_out_of_line();
7571 let handles_before = decoder.remaining_handles();
7572 if let Some((inlined, num_bytes, num_handles)) =
7573 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7574 {
7575 let member_inline_size =
7576 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7577 if inlined != (member_inline_size <= 4) {
7578 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7579 }
7580 let inner_offset;
7581 let mut inner_depth = depth.clone();
7582 if inlined {
7583 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7584 inner_offset = next_offset;
7585 } else {
7586 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7587 inner_depth.increment()?;
7588 }
7589 let val_ref = self.burst_number.get_or_insert_with(|| fidl::new_empty!(u8, D));
7590 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7592 {
7593 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7594 }
7595 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7596 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7597 }
7598 }
7599
7600 next_offset += envelope_size;
7601 _next_ordinal_to_read += 1;
7602 if next_offset >= end_offset {
7603 return Ok(());
7604 }
7605
7606 while _next_ordinal_to_read < 3 {
7608 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7609 _next_ordinal_to_read += 1;
7610 next_offset += envelope_size;
7611 }
7612
7613 let next_out_of_line = decoder.next_out_of_line();
7614 let handles_before = decoder.remaining_handles();
7615 if let Some((inlined, num_bytes, num_handles)) =
7616 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7617 {
7618 let member_inline_size =
7619 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7620 if inlined != (member_inline_size <= 4) {
7621 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7622 }
7623 let inner_offset;
7624 let mut inner_depth = depth.clone();
7625 if inlined {
7626 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7627 inner_offset = next_offset;
7628 } else {
7629 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7630 inner_depth.increment()?;
7631 }
7632 let val_ref = self.flush_timeout.get_or_insert_with(|| fidl::new_empty!(u8, D));
7633 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7634 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7635 {
7636 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7637 }
7638 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7639 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7640 }
7641 }
7642
7643 next_offset += envelope_size;
7644
7645 while next_offset < end_offset {
7647 _next_ordinal_to_read += 1;
7648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7649 next_offset += envelope_size;
7650 }
7651
7652 Ok(())
7653 }
7654 }
7655
7656 impl CodecDelayGetCodecLocalDelayRangeRequest {
7657 #[inline(always)]
7658 fn max_ordinal_present(&self) -> u64 {
7659 if let Some(_) = self.codec_attributes {
7660 return 3;
7661 }
7662 if let Some(_) = self.data_direction {
7663 return 2;
7664 }
7665 if let Some(_) = self.logical_transport_type {
7666 return 1;
7667 }
7668 0
7669 }
7670 }
7671
7672 impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7673 type Borrowed<'a> = &'a Self;
7674 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7675 value
7676 }
7677 }
7678
7679 unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7680 type Owned = Self;
7681
7682 #[inline(always)]
7683 fn inline_align(_context: fidl::encoding::Context) -> usize {
7684 8
7685 }
7686
7687 #[inline(always)]
7688 fn inline_size(_context: fidl::encoding::Context) -> usize {
7689 16
7690 }
7691 }
7692
7693 unsafe impl<D: fidl::encoding::ResourceDialect>
7694 fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeRequest, D>
7695 for &CodecDelayGetCodecLocalDelayRangeRequest
7696 {
7697 unsafe fn encode(
7698 self,
7699 encoder: &mut fidl::encoding::Encoder<'_, D>,
7700 offset: usize,
7701 mut depth: fidl::encoding::Depth,
7702 ) -> fidl::Result<()> {
7703 encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeRequest>(offset);
7704 let max_ordinal: u64 = self.max_ordinal_present();
7706 encoder.write_num(max_ordinal, offset);
7707 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7708 if max_ordinal == 0 {
7710 return Ok(());
7711 }
7712 depth.increment()?;
7713 let envelope_size = 8;
7714 let bytes_len = max_ordinal as usize * envelope_size;
7715 #[allow(unused_variables)]
7716 let offset = encoder.out_of_line_offset(bytes_len);
7717 let mut _prev_end_offset: usize = 0;
7718 if 1 > max_ordinal {
7719 return Ok(());
7720 }
7721
7722 let cur_offset: usize = (1 - 1) * envelope_size;
7725
7726 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7728
7729 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::LogicalTransportType, D>(
7734 self.logical_transport_type.as_ref().map(<fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::ValueTypeMarker>::borrow),
7735 encoder, offset + cur_offset, depth
7736 )?;
7737
7738 _prev_end_offset = cur_offset + envelope_size;
7739 if 2 > max_ordinal {
7740 return Ok(());
7741 }
7742
7743 let cur_offset: usize = (2 - 1) * envelope_size;
7746
7747 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7749
7750 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
7755 self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
7756 encoder, offset + cur_offset, depth
7757 )?;
7758
7759 _prev_end_offset = cur_offset + envelope_size;
7760 if 3 > max_ordinal {
7761 return Ok(());
7762 }
7763
7764 let cur_offset: usize = (3 - 1) * envelope_size;
7767
7768 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7770
7771 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
7776 self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
7777 encoder, offset + cur_offset, depth
7778 )?;
7779
7780 _prev_end_offset = cur_offset + envelope_size;
7781
7782 Ok(())
7783 }
7784 }
7785
7786 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7787 for CodecDelayGetCodecLocalDelayRangeRequest
7788 {
7789 #[inline(always)]
7790 fn new_empty() -> Self {
7791 Self::default()
7792 }
7793
7794 unsafe fn decode(
7795 &mut self,
7796 decoder: &mut fidl::encoding::Decoder<'_, D>,
7797 offset: usize,
7798 mut depth: fidl::encoding::Depth,
7799 ) -> fidl::Result<()> {
7800 decoder.debug_check_bounds::<Self>(offset);
7801 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7802 None => return Err(fidl::Error::NotNullable),
7803 Some(len) => len,
7804 };
7805 if len == 0 {
7807 return Ok(());
7808 };
7809 depth.increment()?;
7810 let envelope_size = 8;
7811 let bytes_len = len * envelope_size;
7812 let offset = decoder.out_of_line_offset(bytes_len)?;
7813 let mut _next_ordinal_to_read = 0;
7815 let mut next_offset = offset;
7816 let end_offset = offset + bytes_len;
7817 _next_ordinal_to_read += 1;
7818 if next_offset >= end_offset {
7819 return Ok(());
7820 }
7821
7822 while _next_ordinal_to_read < 1 {
7824 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7825 _next_ordinal_to_read += 1;
7826 next_offset += envelope_size;
7827 }
7828
7829 let next_out_of_line = decoder.next_out_of_line();
7830 let handles_before = decoder.remaining_handles();
7831 if let Some((inlined, num_bytes, num_handles)) =
7832 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7833 {
7834 let member_inline_size = <fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7835 if inlined != (member_inline_size <= 4) {
7836 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7837 }
7838 let inner_offset;
7839 let mut inner_depth = depth.clone();
7840 if inlined {
7841 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7842 inner_offset = next_offset;
7843 } else {
7844 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7845 inner_depth.increment()?;
7846 }
7847 let val_ref = self.logical_transport_type.get_or_insert_with(|| {
7848 fidl::new_empty!(fidl_fuchsia_bluetooth__common::LogicalTransportType, D)
7849 });
7850 fidl::decode!(
7851 fidl_fuchsia_bluetooth__common::LogicalTransportType,
7852 D,
7853 val_ref,
7854 decoder,
7855 inner_offset,
7856 inner_depth
7857 )?;
7858 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7859 {
7860 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7861 }
7862 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7863 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7864 }
7865 }
7866
7867 next_offset += envelope_size;
7868 _next_ordinal_to_read += 1;
7869 if next_offset >= end_offset {
7870 return Ok(());
7871 }
7872
7873 while _next_ordinal_to_read < 2 {
7875 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7876 _next_ordinal_to_read += 1;
7877 next_offset += envelope_size;
7878 }
7879
7880 let next_out_of_line = decoder.next_out_of_line();
7881 let handles_before = decoder.remaining_handles();
7882 if let Some((inlined, num_bytes, num_handles)) =
7883 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7884 {
7885 let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7886 if inlined != (member_inline_size <= 4) {
7887 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7888 }
7889 let inner_offset;
7890 let mut inner_depth = depth.clone();
7891 if inlined {
7892 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7893 inner_offset = next_offset;
7894 } else {
7895 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7896 inner_depth.increment()?;
7897 }
7898 let val_ref = self.data_direction.get_or_insert_with(|| {
7899 fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
7900 });
7901 fidl::decode!(
7902 fidl_fuchsia_bluetooth__common::DataDirection,
7903 D,
7904 val_ref,
7905 decoder,
7906 inner_offset,
7907 inner_depth
7908 )?;
7909 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7910 {
7911 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7912 }
7913 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7914 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7915 }
7916 }
7917
7918 next_offset += envelope_size;
7919 _next_ordinal_to_read += 1;
7920 if next_offset >= end_offset {
7921 return Ok(());
7922 }
7923
7924 while _next_ordinal_to_read < 3 {
7926 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7927 _next_ordinal_to_read += 1;
7928 next_offset += envelope_size;
7929 }
7930
7931 let next_out_of_line = decoder.next_out_of_line();
7932 let handles_before = decoder.remaining_handles();
7933 if let Some((inlined, num_bytes, num_handles)) =
7934 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7935 {
7936 let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7937 if inlined != (member_inline_size <= 4) {
7938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7939 }
7940 let inner_offset;
7941 let mut inner_depth = depth.clone();
7942 if inlined {
7943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7944 inner_offset = next_offset;
7945 } else {
7946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7947 inner_depth.increment()?;
7948 }
7949 let val_ref = self.codec_attributes.get_or_insert_with(|| {
7950 fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
7951 });
7952 fidl::decode!(
7953 fidl_fuchsia_bluetooth__common::CodecAttributes,
7954 D,
7955 val_ref,
7956 decoder,
7957 inner_offset,
7958 inner_depth
7959 )?;
7960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7961 {
7962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7963 }
7964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7966 }
7967 }
7968
7969 next_offset += envelope_size;
7970
7971 while next_offset < end_offset {
7973 _next_ordinal_to_read += 1;
7974 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7975 next_offset += envelope_size;
7976 }
7977
7978 Ok(())
7979 }
7980 }
7981
7982 impl CodecDelayGetCodecLocalDelayRangeResponse {
7983 #[inline(always)]
7984 fn max_ordinal_present(&self) -> u64 {
7985 if let Some(_) = self.max_controller_delay {
7986 return 2;
7987 }
7988 if let Some(_) = self.min_controller_delay {
7989 return 1;
7990 }
7991 0
7992 }
7993 }
7994
7995 impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7996 type Borrowed<'a> = &'a Self;
7997 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7998 value
7999 }
8000 }
8001
8002 unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
8003 type Owned = Self;
8004
8005 #[inline(always)]
8006 fn inline_align(_context: fidl::encoding::Context) -> usize {
8007 8
8008 }
8009
8010 #[inline(always)]
8011 fn inline_size(_context: fidl::encoding::Context) -> usize {
8012 16
8013 }
8014 }
8015
8016 unsafe impl<D: fidl::encoding::ResourceDialect>
8017 fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeResponse, D>
8018 for &CodecDelayGetCodecLocalDelayRangeResponse
8019 {
8020 unsafe fn encode(
8021 self,
8022 encoder: &mut fidl::encoding::Encoder<'_, D>,
8023 offset: usize,
8024 mut depth: fidl::encoding::Depth,
8025 ) -> fidl::Result<()> {
8026 encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeResponse>(offset);
8027 let max_ordinal: u64 = self.max_ordinal_present();
8029 encoder.write_num(max_ordinal, offset);
8030 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8031 if max_ordinal == 0 {
8033 return Ok(());
8034 }
8035 depth.increment()?;
8036 let envelope_size = 8;
8037 let bytes_len = max_ordinal as usize * envelope_size;
8038 #[allow(unused_variables)]
8039 let offset = encoder.out_of_line_offset(bytes_len);
8040 let mut _prev_end_offset: usize = 0;
8041 if 1 > max_ordinal {
8042 return Ok(());
8043 }
8044
8045 let cur_offset: usize = (1 - 1) * envelope_size;
8048
8049 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8051
8052 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8057 self.min_controller_delay
8058 .as_ref()
8059 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8060 encoder,
8061 offset + cur_offset,
8062 depth,
8063 )?;
8064
8065 _prev_end_offset = cur_offset + envelope_size;
8066 if 2 > max_ordinal {
8067 return Ok(());
8068 }
8069
8070 let cur_offset: usize = (2 - 1) * envelope_size;
8073
8074 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8076
8077 fidl::encoding::encode_in_envelope_optional::<i64, D>(
8082 self.max_controller_delay
8083 .as_ref()
8084 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8085 encoder,
8086 offset + cur_offset,
8087 depth,
8088 )?;
8089
8090 _prev_end_offset = cur_offset + envelope_size;
8091
8092 Ok(())
8093 }
8094 }
8095
8096 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8097 for CodecDelayGetCodecLocalDelayRangeResponse
8098 {
8099 #[inline(always)]
8100 fn new_empty() -> Self {
8101 Self::default()
8102 }
8103
8104 unsafe fn decode(
8105 &mut self,
8106 decoder: &mut fidl::encoding::Decoder<'_, D>,
8107 offset: usize,
8108 mut depth: fidl::encoding::Depth,
8109 ) -> fidl::Result<()> {
8110 decoder.debug_check_bounds::<Self>(offset);
8111 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8112 None => return Err(fidl::Error::NotNullable),
8113 Some(len) => len,
8114 };
8115 if len == 0 {
8117 return Ok(());
8118 };
8119 depth.increment()?;
8120 let envelope_size = 8;
8121 let bytes_len = len * envelope_size;
8122 let offset = decoder.out_of_line_offset(bytes_len)?;
8123 let mut _next_ordinal_to_read = 0;
8125 let mut next_offset = offset;
8126 let end_offset = offset + bytes_len;
8127 _next_ordinal_to_read += 1;
8128 if next_offset >= end_offset {
8129 return Ok(());
8130 }
8131
8132 while _next_ordinal_to_read < 1 {
8134 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8135 _next_ordinal_to_read += 1;
8136 next_offset += envelope_size;
8137 }
8138
8139 let next_out_of_line = decoder.next_out_of_line();
8140 let handles_before = decoder.remaining_handles();
8141 if let Some((inlined, num_bytes, num_handles)) =
8142 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8143 {
8144 let member_inline_size =
8145 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8146 if inlined != (member_inline_size <= 4) {
8147 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8148 }
8149 let inner_offset;
8150 let mut inner_depth = depth.clone();
8151 if inlined {
8152 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8153 inner_offset = next_offset;
8154 } else {
8155 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8156 inner_depth.increment()?;
8157 }
8158 let val_ref =
8159 self.min_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8160 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8161 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8162 {
8163 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8164 }
8165 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8166 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8167 }
8168 }
8169
8170 next_offset += envelope_size;
8171 _next_ordinal_to_read += 1;
8172 if next_offset >= end_offset {
8173 return Ok(());
8174 }
8175
8176 while _next_ordinal_to_read < 2 {
8178 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8179 _next_ordinal_to_read += 1;
8180 next_offset += envelope_size;
8181 }
8182
8183 let next_out_of_line = decoder.next_out_of_line();
8184 let handles_before = decoder.remaining_handles();
8185 if let Some((inlined, num_bytes, num_handles)) =
8186 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8187 {
8188 let member_inline_size =
8189 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8190 if inlined != (member_inline_size <= 4) {
8191 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8192 }
8193 let inner_offset;
8194 let mut inner_depth = depth.clone();
8195 if inlined {
8196 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8197 inner_offset = next_offset;
8198 } else {
8199 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8200 inner_depth.increment()?;
8201 }
8202 let val_ref =
8203 self.max_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8204 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8205 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8206 {
8207 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8208 }
8209 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8210 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8211 }
8212 }
8213
8214 next_offset += envelope_size;
8215
8216 while next_offset < end_offset {
8218 _next_ordinal_to_read += 1;
8219 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8220 next_offset += envelope_size;
8221 }
8222
8223 Ok(())
8224 }
8225 }
8226
8227 impl ConnectedIsochronousGroupEstablishStreamsRequest {
8228 #[inline(always)]
8229 fn max_ordinal_present(&self) -> u64 {
8230 if let Some(_) = self.cis_params {
8231 return 1;
8232 }
8233 0
8234 }
8235 }
8236
8237 impl fidl::encoding::ValueTypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8238 type Borrowed<'a> = &'a Self;
8239 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8240 value
8241 }
8242 }
8243
8244 unsafe impl fidl::encoding::TypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8245 type Owned = Self;
8246
8247 #[inline(always)]
8248 fn inline_align(_context: fidl::encoding::Context) -> usize {
8249 8
8250 }
8251
8252 #[inline(always)]
8253 fn inline_size(_context: fidl::encoding::Context) -> usize {
8254 16
8255 }
8256 }
8257
8258 unsafe impl<D: fidl::encoding::ResourceDialect>
8259 fidl::encoding::Encode<ConnectedIsochronousGroupEstablishStreamsRequest, D>
8260 for &ConnectedIsochronousGroupEstablishStreamsRequest
8261 {
8262 unsafe fn encode(
8263 self,
8264 encoder: &mut fidl::encoding::Encoder<'_, D>,
8265 offset: usize,
8266 mut depth: fidl::encoding::Depth,
8267 ) -> fidl::Result<()> {
8268 encoder.debug_check_bounds::<ConnectedIsochronousGroupEstablishStreamsRequest>(offset);
8269 let max_ordinal: u64 = self.max_ordinal_present();
8271 encoder.write_num(max_ordinal, offset);
8272 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8273 if max_ordinal == 0 {
8275 return Ok(());
8276 }
8277 depth.increment()?;
8278 let envelope_size = 8;
8279 let bytes_len = max_ordinal as usize * envelope_size;
8280 #[allow(unused_variables)]
8281 let offset = encoder.out_of_line_offset(bytes_len);
8282 let mut _prev_end_offset: usize = 0;
8283 if 1 > max_ordinal {
8284 return Ok(());
8285 }
8286
8287 let cur_offset: usize = (1 - 1) * envelope_size;
8290
8291 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8293
8294 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CisParameters, 31>, D>(
8299 self.cis_params.as_ref().map(<fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::ValueTypeMarker>::borrow),
8300 encoder, offset + cur_offset, depth
8301 )?;
8302
8303 _prev_end_offset = cur_offset + envelope_size;
8304
8305 Ok(())
8306 }
8307 }
8308
8309 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8310 for ConnectedIsochronousGroupEstablishStreamsRequest
8311 {
8312 #[inline(always)]
8313 fn new_empty() -> Self {
8314 Self::default()
8315 }
8316
8317 unsafe fn decode(
8318 &mut self,
8319 decoder: &mut fidl::encoding::Decoder<'_, D>,
8320 offset: usize,
8321 mut depth: fidl::encoding::Depth,
8322 ) -> fidl::Result<()> {
8323 decoder.debug_check_bounds::<Self>(offset);
8324 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8325 None => return Err(fidl::Error::NotNullable),
8326 Some(len) => len,
8327 };
8328 if len == 0 {
8330 return Ok(());
8331 };
8332 depth.increment()?;
8333 let envelope_size = 8;
8334 let bytes_len = len * envelope_size;
8335 let offset = decoder.out_of_line_offset(bytes_len)?;
8336 let mut _next_ordinal_to_read = 0;
8338 let mut next_offset = offset;
8339 let end_offset = offset + bytes_len;
8340 _next_ordinal_to_read += 1;
8341 if next_offset >= end_offset {
8342 return Ok(());
8343 }
8344
8345 while _next_ordinal_to_read < 1 {
8347 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8348 _next_ordinal_to_read += 1;
8349 next_offset += envelope_size;
8350 }
8351
8352 let next_out_of_line = decoder.next_out_of_line();
8353 let handles_before = decoder.remaining_handles();
8354 if let Some((inlined, num_bytes, num_handles)) =
8355 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8356 {
8357 let member_inline_size = <fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8358 if inlined != (member_inline_size <= 4) {
8359 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8360 }
8361 let inner_offset;
8362 let mut inner_depth = depth.clone();
8363 if inlined {
8364 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8365 inner_offset = next_offset;
8366 } else {
8367 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8368 inner_depth.increment()?;
8369 }
8370 let val_ref = self.cis_params.get_or_insert_with(
8371 || fidl::new_empty!(fidl::encoding::Vector<CisParameters, 31>, D),
8372 );
8373 fidl::decode!(fidl::encoding::Vector<CisParameters, 31>, D, val_ref, decoder, inner_offset, inner_depth)?;
8374 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8375 {
8376 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8377 }
8378 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8379 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8380 }
8381 }
8382
8383 next_offset += envelope_size;
8384
8385 while next_offset < end_offset {
8387 _next_ordinal_to_read += 1;
8388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8389 next_offset += envelope_size;
8390 }
8391
8392 Ok(())
8393 }
8394 }
8395
8396 impl ConnectionOptions {
8397 #[inline(always)]
8398 fn max_ordinal_present(&self) -> u64 {
8399 if let Some(_) = self.service_filter {
8400 return 2;
8401 }
8402 if let Some(_) = self.bondable_mode {
8403 return 1;
8404 }
8405 0
8406 }
8407 }
8408
8409 impl fidl::encoding::ValueTypeMarker for ConnectionOptions {
8410 type Borrowed<'a> = &'a Self;
8411 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8412 value
8413 }
8414 }
8415
8416 unsafe impl fidl::encoding::TypeMarker for ConnectionOptions {
8417 type Owned = Self;
8418
8419 #[inline(always)]
8420 fn inline_align(_context: fidl::encoding::Context) -> usize {
8421 8
8422 }
8423
8424 #[inline(always)]
8425 fn inline_size(_context: fidl::encoding::Context) -> usize {
8426 16
8427 }
8428 }
8429
8430 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionOptions, D>
8431 for &ConnectionOptions
8432 {
8433 unsafe fn encode(
8434 self,
8435 encoder: &mut fidl::encoding::Encoder<'_, D>,
8436 offset: usize,
8437 mut depth: fidl::encoding::Depth,
8438 ) -> fidl::Result<()> {
8439 encoder.debug_check_bounds::<ConnectionOptions>(offset);
8440 let max_ordinal: u64 = self.max_ordinal_present();
8442 encoder.write_num(max_ordinal, offset);
8443 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8444 if max_ordinal == 0 {
8446 return Ok(());
8447 }
8448 depth.increment()?;
8449 let envelope_size = 8;
8450 let bytes_len = max_ordinal as usize * envelope_size;
8451 #[allow(unused_variables)]
8452 let offset = encoder.out_of_line_offset(bytes_len);
8453 let mut _prev_end_offset: usize = 0;
8454 if 1 > max_ordinal {
8455 return Ok(());
8456 }
8457
8458 let cur_offset: usize = (1 - 1) * envelope_size;
8461
8462 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8464
8465 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8470 self.bondable_mode.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8471 encoder,
8472 offset + cur_offset,
8473 depth,
8474 )?;
8475
8476 _prev_end_offset = cur_offset + envelope_size;
8477 if 2 > max_ordinal {
8478 return Ok(());
8479 }
8480
8481 let cur_offset: usize = (2 - 1) * envelope_size;
8484
8485 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8487
8488 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8493 self.service_filter.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8494 encoder, offset + cur_offset, depth
8495 )?;
8496
8497 _prev_end_offset = cur_offset + envelope_size;
8498
8499 Ok(())
8500 }
8501 }
8502
8503 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionOptions {
8504 #[inline(always)]
8505 fn new_empty() -> Self {
8506 Self::default()
8507 }
8508
8509 unsafe fn decode(
8510 &mut self,
8511 decoder: &mut fidl::encoding::Decoder<'_, D>,
8512 offset: usize,
8513 mut depth: fidl::encoding::Depth,
8514 ) -> fidl::Result<()> {
8515 decoder.debug_check_bounds::<Self>(offset);
8516 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8517 None => return Err(fidl::Error::NotNullable),
8518 Some(len) => len,
8519 };
8520 if len == 0 {
8522 return Ok(());
8523 };
8524 depth.increment()?;
8525 let envelope_size = 8;
8526 let bytes_len = len * envelope_size;
8527 let offset = decoder.out_of_line_offset(bytes_len)?;
8528 let mut _next_ordinal_to_read = 0;
8530 let mut next_offset = offset;
8531 let end_offset = offset + bytes_len;
8532 _next_ordinal_to_read += 1;
8533 if next_offset >= end_offset {
8534 return Ok(());
8535 }
8536
8537 while _next_ordinal_to_read < 1 {
8539 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8540 _next_ordinal_to_read += 1;
8541 next_offset += envelope_size;
8542 }
8543
8544 let next_out_of_line = decoder.next_out_of_line();
8545 let handles_before = decoder.remaining_handles();
8546 if let Some((inlined, num_bytes, num_handles)) =
8547 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8548 {
8549 let member_inline_size =
8550 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8551 if inlined != (member_inline_size <= 4) {
8552 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8553 }
8554 let inner_offset;
8555 let mut inner_depth = depth.clone();
8556 if inlined {
8557 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8558 inner_offset = next_offset;
8559 } else {
8560 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8561 inner_depth.increment()?;
8562 }
8563 let val_ref = self.bondable_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
8564 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8565 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8566 {
8567 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8568 }
8569 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8570 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8571 }
8572 }
8573
8574 next_offset += envelope_size;
8575 _next_ordinal_to_read += 1;
8576 if next_offset >= end_offset {
8577 return Ok(());
8578 }
8579
8580 while _next_ordinal_to_read < 2 {
8582 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8583 _next_ordinal_to_read += 1;
8584 next_offset += envelope_size;
8585 }
8586
8587 let next_out_of_line = decoder.next_out_of_line();
8588 let handles_before = decoder.remaining_handles();
8589 if let Some((inlined, num_bytes, num_handles)) =
8590 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8591 {
8592 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8593 if inlined != (member_inline_size <= 4) {
8594 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8595 }
8596 let inner_offset;
8597 let mut inner_depth = depth.clone();
8598 if inlined {
8599 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8600 inner_offset = next_offset;
8601 } else {
8602 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8603 inner_depth.increment()?;
8604 }
8605 let val_ref = self.service_filter.get_or_insert_with(|| {
8606 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8607 });
8608 fidl::decode!(
8609 fidl_fuchsia_bluetooth__common::Uuid,
8610 D,
8611 val_ref,
8612 decoder,
8613 inner_offset,
8614 inner_depth
8615 )?;
8616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8617 {
8618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8619 }
8620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8622 }
8623 }
8624
8625 next_offset += envelope_size;
8626
8627 while next_offset < end_offset {
8629 _next_ordinal_to_read += 1;
8630 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8631 next_offset += envelope_size;
8632 }
8633
8634 Ok(())
8635 }
8636 }
8637
8638 impl Extended {
8639 #[inline(always)]
8640 fn max_ordinal_present(&self) -> u64 {
8641 0
8642 }
8643 }
8644
8645 impl fidl::encoding::ValueTypeMarker for Extended {
8646 type Borrowed<'a> = &'a Self;
8647 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8648 value
8649 }
8650 }
8651
8652 unsafe impl fidl::encoding::TypeMarker for Extended {
8653 type Owned = Self;
8654
8655 #[inline(always)]
8656 fn inline_align(_context: fidl::encoding::Context) -> usize {
8657 8
8658 }
8659
8660 #[inline(always)]
8661 fn inline_size(_context: fidl::encoding::Context) -> usize {
8662 16
8663 }
8664 }
8665
8666 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Extended, D> for &Extended {
8667 unsafe fn encode(
8668 self,
8669 encoder: &mut fidl::encoding::Encoder<'_, D>,
8670 offset: usize,
8671 mut depth: fidl::encoding::Depth,
8672 ) -> fidl::Result<()> {
8673 encoder.debug_check_bounds::<Extended>(offset);
8674 let max_ordinal: u64 = self.max_ordinal_present();
8676 encoder.write_num(max_ordinal, offset);
8677 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8678 if max_ordinal == 0 {
8680 return Ok(());
8681 }
8682 depth.increment()?;
8683 let envelope_size = 8;
8684 let bytes_len = max_ordinal as usize * envelope_size;
8685 #[allow(unused_variables)]
8686 let offset = encoder.out_of_line_offset(bytes_len);
8687 let mut _prev_end_offset: usize = 0;
8688
8689 Ok(())
8690 }
8691 }
8692
8693 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Extended {
8694 #[inline(always)]
8695 fn new_empty() -> Self {
8696 Self::default()
8697 }
8698
8699 unsafe fn decode(
8700 &mut self,
8701 decoder: &mut fidl::encoding::Decoder<'_, D>,
8702 offset: usize,
8703 mut depth: fidl::encoding::Depth,
8704 ) -> fidl::Result<()> {
8705 decoder.debug_check_bounds::<Self>(offset);
8706 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8707 None => return Err(fidl::Error::NotNullable),
8708 Some(len) => len,
8709 };
8710 if len == 0 {
8712 return Ok(());
8713 };
8714 depth.increment()?;
8715 let envelope_size = 8;
8716 let bytes_len = len * envelope_size;
8717 let offset = decoder.out_of_line_offset(bytes_len)?;
8718 let mut _next_ordinal_to_read = 0;
8720 let mut next_offset = offset;
8721 let end_offset = offset + bytes_len;
8722
8723 while next_offset < end_offset {
8725 _next_ordinal_to_read += 1;
8726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8727 next_offset += envelope_size;
8728 }
8729
8730 Ok(())
8731 }
8732 }
8733
8734 impl Filter {
8735 #[inline(always)]
8736 fn max_ordinal_present(&self) -> u64 {
8737 if let Some(_) = self.solicitation_uuid {
8738 return 7;
8739 }
8740 if let Some(_) = self.max_path_loss {
8741 return 6;
8742 }
8743 if let Some(_) = self.name {
8744 return 5;
8745 }
8746 if let Some(_) = self.connectable {
8747 return 4;
8748 }
8749 if let Some(_) = self.manufacturer_id {
8750 return 3;
8751 }
8752 if let Some(_) = self.service_data_uuid {
8753 return 2;
8754 }
8755 if let Some(_) = self.service_uuid {
8756 return 1;
8757 }
8758 0
8759 }
8760 }
8761
8762 impl fidl::encoding::ValueTypeMarker for Filter {
8763 type Borrowed<'a> = &'a Self;
8764 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8765 value
8766 }
8767 }
8768
8769 unsafe impl fidl::encoding::TypeMarker for Filter {
8770 type Owned = Self;
8771
8772 #[inline(always)]
8773 fn inline_align(_context: fidl::encoding::Context) -> usize {
8774 8
8775 }
8776
8777 #[inline(always)]
8778 fn inline_size(_context: fidl::encoding::Context) -> usize {
8779 16
8780 }
8781 }
8782
8783 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Filter, D> for &Filter {
8784 unsafe fn encode(
8785 self,
8786 encoder: &mut fidl::encoding::Encoder<'_, D>,
8787 offset: usize,
8788 mut depth: fidl::encoding::Depth,
8789 ) -> fidl::Result<()> {
8790 encoder.debug_check_bounds::<Filter>(offset);
8791 let max_ordinal: u64 = self.max_ordinal_present();
8793 encoder.write_num(max_ordinal, offset);
8794 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8795 if max_ordinal == 0 {
8797 return Ok(());
8798 }
8799 depth.increment()?;
8800 let envelope_size = 8;
8801 let bytes_len = max_ordinal as usize * envelope_size;
8802 #[allow(unused_variables)]
8803 let offset = encoder.out_of_line_offset(bytes_len);
8804 let mut _prev_end_offset: usize = 0;
8805 if 1 > max_ordinal {
8806 return Ok(());
8807 }
8808
8809 let cur_offset: usize = (1 - 1) * envelope_size;
8812
8813 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8815
8816 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8821 self.service_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8822 encoder, offset + cur_offset, depth
8823 )?;
8824
8825 _prev_end_offset = cur_offset + envelope_size;
8826 if 2 > max_ordinal {
8827 return Ok(());
8828 }
8829
8830 let cur_offset: usize = (2 - 1) * envelope_size;
8833
8834 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8836
8837 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8842 self.service_data_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8843 encoder, offset + cur_offset, depth
8844 )?;
8845
8846 _prev_end_offset = cur_offset + envelope_size;
8847 if 3 > max_ordinal {
8848 return Ok(());
8849 }
8850
8851 let cur_offset: usize = (3 - 1) * envelope_size;
8854
8855 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8857
8858 fidl::encoding::encode_in_envelope_optional::<u16, D>(
8863 self.manufacturer_id.as_ref().map(<u16 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 4 > max_ordinal {
8871 return Ok(());
8872 }
8873
8874 let cur_offset: usize = (4 - 1) * envelope_size;
8877
8878 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8880
8881 fidl::encoding::encode_in_envelope_optional::<bool, D>(
8886 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8887 encoder,
8888 offset + cur_offset,
8889 depth,
8890 )?;
8891
8892 _prev_end_offset = cur_offset + envelope_size;
8893 if 5 > max_ordinal {
8894 return Ok(());
8895 }
8896
8897 let cur_offset: usize = (5 - 1) * envelope_size;
8900
8901 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8903
8904 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
8909 self.name.as_ref().map(
8910 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
8911 ),
8912 encoder,
8913 offset + cur_offset,
8914 depth,
8915 )?;
8916
8917 _prev_end_offset = cur_offset + envelope_size;
8918 if 6 > max_ordinal {
8919 return Ok(());
8920 }
8921
8922 let cur_offset: usize = (6 - 1) * envelope_size;
8925
8926 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8928
8929 fidl::encoding::encode_in_envelope_optional::<i8, D>(
8934 self.max_path_loss.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
8935 encoder,
8936 offset + cur_offset,
8937 depth,
8938 )?;
8939
8940 _prev_end_offset = cur_offset + envelope_size;
8941 if 7 > max_ordinal {
8942 return Ok(());
8943 }
8944
8945 let cur_offset: usize = (7 - 1) * envelope_size;
8948
8949 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8951
8952 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8957 self.solicitation_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8958 encoder, offset + cur_offset, depth
8959 )?;
8960
8961 _prev_end_offset = cur_offset + envelope_size;
8962
8963 Ok(())
8964 }
8965 }
8966
8967 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Filter {
8968 #[inline(always)]
8969 fn new_empty() -> Self {
8970 Self::default()
8971 }
8972
8973 unsafe fn decode(
8974 &mut self,
8975 decoder: &mut fidl::encoding::Decoder<'_, D>,
8976 offset: usize,
8977 mut depth: fidl::encoding::Depth,
8978 ) -> fidl::Result<()> {
8979 decoder.debug_check_bounds::<Self>(offset);
8980 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8981 None => return Err(fidl::Error::NotNullable),
8982 Some(len) => len,
8983 };
8984 if len == 0 {
8986 return Ok(());
8987 };
8988 depth.increment()?;
8989 let envelope_size = 8;
8990 let bytes_len = len * envelope_size;
8991 let offset = decoder.out_of_line_offset(bytes_len)?;
8992 let mut _next_ordinal_to_read = 0;
8994 let mut next_offset = offset;
8995 let end_offset = offset + bytes_len;
8996 _next_ordinal_to_read += 1;
8997 if next_offset >= end_offset {
8998 return Ok(());
8999 }
9000
9001 while _next_ordinal_to_read < 1 {
9003 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9004 _next_ordinal_to_read += 1;
9005 next_offset += envelope_size;
9006 }
9007
9008 let next_out_of_line = decoder.next_out_of_line();
9009 let handles_before = decoder.remaining_handles();
9010 if let Some((inlined, num_bytes, num_handles)) =
9011 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9012 {
9013 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9014 if inlined != (member_inline_size <= 4) {
9015 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9016 }
9017 let inner_offset;
9018 let mut inner_depth = depth.clone();
9019 if inlined {
9020 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9021 inner_offset = next_offset;
9022 } else {
9023 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9024 inner_depth.increment()?;
9025 }
9026 let val_ref = self.service_uuid.get_or_insert_with(|| {
9027 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9028 });
9029 fidl::decode!(
9030 fidl_fuchsia_bluetooth__common::Uuid,
9031 D,
9032 val_ref,
9033 decoder,
9034 inner_offset,
9035 inner_depth
9036 )?;
9037 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9038 {
9039 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9040 }
9041 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9042 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9043 }
9044 }
9045
9046 next_offset += envelope_size;
9047 _next_ordinal_to_read += 1;
9048 if next_offset >= end_offset {
9049 return Ok(());
9050 }
9051
9052 while _next_ordinal_to_read < 2 {
9054 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9055 _next_ordinal_to_read += 1;
9056 next_offset += envelope_size;
9057 }
9058
9059 let next_out_of_line = decoder.next_out_of_line();
9060 let handles_before = decoder.remaining_handles();
9061 if let Some((inlined, num_bytes, num_handles)) =
9062 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9063 {
9064 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9065 if inlined != (member_inline_size <= 4) {
9066 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9067 }
9068 let inner_offset;
9069 let mut inner_depth = depth.clone();
9070 if inlined {
9071 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9072 inner_offset = next_offset;
9073 } else {
9074 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9075 inner_depth.increment()?;
9076 }
9077 let val_ref = self.service_data_uuid.get_or_insert_with(|| {
9078 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9079 });
9080 fidl::decode!(
9081 fidl_fuchsia_bluetooth__common::Uuid,
9082 D,
9083 val_ref,
9084 decoder,
9085 inner_offset,
9086 inner_depth
9087 )?;
9088 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9089 {
9090 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9091 }
9092 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9093 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9094 }
9095 }
9096
9097 next_offset += envelope_size;
9098 _next_ordinal_to_read += 1;
9099 if next_offset >= end_offset {
9100 return Ok(());
9101 }
9102
9103 while _next_ordinal_to_read < 3 {
9105 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9106 _next_ordinal_to_read += 1;
9107 next_offset += envelope_size;
9108 }
9109
9110 let next_out_of_line = decoder.next_out_of_line();
9111 let handles_before = decoder.remaining_handles();
9112 if let Some((inlined, num_bytes, num_handles)) =
9113 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9114 {
9115 let member_inline_size =
9116 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9117 if inlined != (member_inline_size <= 4) {
9118 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9119 }
9120 let inner_offset;
9121 let mut inner_depth = depth.clone();
9122 if inlined {
9123 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9124 inner_offset = next_offset;
9125 } else {
9126 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9127 inner_depth.increment()?;
9128 }
9129 let val_ref = self.manufacturer_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9130 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9131 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9132 {
9133 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9134 }
9135 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9136 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9137 }
9138 }
9139
9140 next_offset += envelope_size;
9141 _next_ordinal_to_read += 1;
9142 if next_offset >= end_offset {
9143 return Ok(());
9144 }
9145
9146 while _next_ordinal_to_read < 4 {
9148 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9149 _next_ordinal_to_read += 1;
9150 next_offset += envelope_size;
9151 }
9152
9153 let next_out_of_line = decoder.next_out_of_line();
9154 let handles_before = decoder.remaining_handles();
9155 if let Some((inlined, num_bytes, num_handles)) =
9156 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9157 {
9158 let member_inline_size =
9159 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9160 if inlined != (member_inline_size <= 4) {
9161 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9162 }
9163 let inner_offset;
9164 let mut inner_depth = depth.clone();
9165 if inlined {
9166 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9167 inner_offset = next_offset;
9168 } else {
9169 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9170 inner_depth.increment()?;
9171 }
9172 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
9173 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9174 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9175 {
9176 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9177 }
9178 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9179 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9180 }
9181 }
9182
9183 next_offset += envelope_size;
9184 _next_ordinal_to_read += 1;
9185 if next_offset >= end_offset {
9186 return Ok(());
9187 }
9188
9189 while _next_ordinal_to_read < 5 {
9191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9192 _next_ordinal_to_read += 1;
9193 next_offset += envelope_size;
9194 }
9195
9196 let next_out_of_line = decoder.next_out_of_line();
9197 let handles_before = decoder.remaining_handles();
9198 if let Some((inlined, num_bytes, num_handles)) =
9199 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9200 {
9201 let member_inline_size =
9202 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
9203 decoder.context,
9204 );
9205 if inlined != (member_inline_size <= 4) {
9206 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9207 }
9208 let inner_offset;
9209 let mut inner_depth = depth.clone();
9210 if inlined {
9211 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9212 inner_offset = next_offset;
9213 } else {
9214 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9215 inner_depth.increment()?;
9216 }
9217 let val_ref = self
9218 .name
9219 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
9220 fidl::decode!(
9221 fidl::encoding::BoundedString<248>,
9222 D,
9223 val_ref,
9224 decoder,
9225 inner_offset,
9226 inner_depth
9227 )?;
9228 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9229 {
9230 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9231 }
9232 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9233 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9234 }
9235 }
9236
9237 next_offset += envelope_size;
9238 _next_ordinal_to_read += 1;
9239 if next_offset >= end_offset {
9240 return Ok(());
9241 }
9242
9243 while _next_ordinal_to_read < 6 {
9245 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9246 _next_ordinal_to_read += 1;
9247 next_offset += envelope_size;
9248 }
9249
9250 let next_out_of_line = decoder.next_out_of_line();
9251 let handles_before = decoder.remaining_handles();
9252 if let Some((inlined, num_bytes, num_handles)) =
9253 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9254 {
9255 let member_inline_size =
9256 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9257 if inlined != (member_inline_size <= 4) {
9258 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9259 }
9260 let inner_offset;
9261 let mut inner_depth = depth.clone();
9262 if inlined {
9263 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9264 inner_offset = next_offset;
9265 } else {
9266 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9267 inner_depth.increment()?;
9268 }
9269 let val_ref = self.max_path_loss.get_or_insert_with(|| fidl::new_empty!(i8, D));
9270 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
9271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9272 {
9273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9274 }
9275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9277 }
9278 }
9279
9280 next_offset += envelope_size;
9281 _next_ordinal_to_read += 1;
9282 if next_offset >= end_offset {
9283 return Ok(());
9284 }
9285
9286 while _next_ordinal_to_read < 7 {
9288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9289 _next_ordinal_to_read += 1;
9290 next_offset += envelope_size;
9291 }
9292
9293 let next_out_of_line = decoder.next_out_of_line();
9294 let handles_before = decoder.remaining_handles();
9295 if let Some((inlined, num_bytes, num_handles)) =
9296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9297 {
9298 let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9299 if inlined != (member_inline_size <= 4) {
9300 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9301 }
9302 let inner_offset;
9303 let mut inner_depth = depth.clone();
9304 if inlined {
9305 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9306 inner_offset = next_offset;
9307 } else {
9308 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9309 inner_depth.increment()?;
9310 }
9311 let val_ref = self.solicitation_uuid.get_or_insert_with(|| {
9312 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9313 });
9314 fidl::decode!(
9315 fidl_fuchsia_bluetooth__common::Uuid,
9316 D,
9317 val_ref,
9318 decoder,
9319 inner_offset,
9320 inner_depth
9321 )?;
9322 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9323 {
9324 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9325 }
9326 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9327 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9328 }
9329 }
9330
9331 next_offset += envelope_size;
9332
9333 while next_offset < end_offset {
9335 _next_ordinal_to_read += 1;
9336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9337 next_offset += envelope_size;
9338 }
9339
9340 Ok(())
9341 }
9342 }
9343
9344 impl IsochronousStreamOnEstablishedRequest {
9345 #[inline(always)]
9346 fn max_ordinal_present(&self) -> u64 {
9347 if let Some(_) = self.established_params {
9348 return 2;
9349 }
9350 if let Some(_) = self.result {
9351 return 1;
9352 }
9353 0
9354 }
9355 }
9356
9357 impl fidl::encoding::ValueTypeMarker for IsochronousStreamOnEstablishedRequest {
9358 type Borrowed<'a> = &'a Self;
9359 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9360 value
9361 }
9362 }
9363
9364 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamOnEstablishedRequest {
9365 type Owned = Self;
9366
9367 #[inline(always)]
9368 fn inline_align(_context: fidl::encoding::Context) -> usize {
9369 8
9370 }
9371
9372 #[inline(always)]
9373 fn inline_size(_context: fidl::encoding::Context) -> usize {
9374 16
9375 }
9376 }
9377
9378 unsafe impl<D: fidl::encoding::ResourceDialect>
9379 fidl::encoding::Encode<IsochronousStreamOnEstablishedRequest, D>
9380 for &IsochronousStreamOnEstablishedRequest
9381 {
9382 unsafe fn encode(
9383 self,
9384 encoder: &mut fidl::encoding::Encoder<'_, D>,
9385 offset: usize,
9386 mut depth: fidl::encoding::Depth,
9387 ) -> fidl::Result<()> {
9388 encoder.debug_check_bounds::<IsochronousStreamOnEstablishedRequest>(offset);
9389 let max_ordinal: u64 = self.max_ordinal_present();
9391 encoder.write_num(max_ordinal, offset);
9392 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9393 if max_ordinal == 0 {
9395 return Ok(());
9396 }
9397 depth.increment()?;
9398 let envelope_size = 8;
9399 let bytes_len = max_ordinal as usize * envelope_size;
9400 #[allow(unused_variables)]
9401 let offset = encoder.out_of_line_offset(bytes_len);
9402 let mut _prev_end_offset: usize = 0;
9403 if 1 > max_ordinal {
9404 return Ok(());
9405 }
9406
9407 let cur_offset: usize = (1 - 1) * envelope_size;
9410
9411 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9413
9414 fidl::encoding::encode_in_envelope_optional::<i32, D>(
9419 self.result.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
9420 encoder,
9421 offset + cur_offset,
9422 depth,
9423 )?;
9424
9425 _prev_end_offset = cur_offset + envelope_size;
9426 if 2 > max_ordinal {
9427 return Ok(());
9428 }
9429
9430 let cur_offset: usize = (2 - 1) * envelope_size;
9433
9434 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9436
9437 fidl::encoding::encode_in_envelope_optional::<CisEstablishedParameters, D>(
9442 self.established_params
9443 .as_ref()
9444 .map(<CisEstablishedParameters as fidl::encoding::ValueTypeMarker>::borrow),
9445 encoder,
9446 offset + cur_offset,
9447 depth,
9448 )?;
9449
9450 _prev_end_offset = cur_offset + envelope_size;
9451
9452 Ok(())
9453 }
9454 }
9455
9456 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9457 for IsochronousStreamOnEstablishedRequest
9458 {
9459 #[inline(always)]
9460 fn new_empty() -> Self {
9461 Self::default()
9462 }
9463
9464 unsafe fn decode(
9465 &mut self,
9466 decoder: &mut fidl::encoding::Decoder<'_, D>,
9467 offset: usize,
9468 mut depth: fidl::encoding::Depth,
9469 ) -> fidl::Result<()> {
9470 decoder.debug_check_bounds::<Self>(offset);
9471 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9472 None => return Err(fidl::Error::NotNullable),
9473 Some(len) => len,
9474 };
9475 if len == 0 {
9477 return Ok(());
9478 };
9479 depth.increment()?;
9480 let envelope_size = 8;
9481 let bytes_len = len * envelope_size;
9482 let offset = decoder.out_of_line_offset(bytes_len)?;
9483 let mut _next_ordinal_to_read = 0;
9485 let mut next_offset = offset;
9486 let end_offset = offset + bytes_len;
9487 _next_ordinal_to_read += 1;
9488 if next_offset >= end_offset {
9489 return Ok(());
9490 }
9491
9492 while _next_ordinal_to_read < 1 {
9494 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9495 _next_ordinal_to_read += 1;
9496 next_offset += envelope_size;
9497 }
9498
9499 let next_out_of_line = decoder.next_out_of_line();
9500 let handles_before = decoder.remaining_handles();
9501 if let Some((inlined, num_bytes, num_handles)) =
9502 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9503 {
9504 let member_inline_size =
9505 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9506 if inlined != (member_inline_size <= 4) {
9507 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9508 }
9509 let inner_offset;
9510 let mut inner_depth = depth.clone();
9511 if inlined {
9512 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9513 inner_offset = next_offset;
9514 } else {
9515 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9516 inner_depth.increment()?;
9517 }
9518 let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(i32, D));
9519 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
9520 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9521 {
9522 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9523 }
9524 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9525 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9526 }
9527 }
9528
9529 next_offset += envelope_size;
9530 _next_ordinal_to_read += 1;
9531 if next_offset >= end_offset {
9532 return Ok(());
9533 }
9534
9535 while _next_ordinal_to_read < 2 {
9537 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9538 _next_ordinal_to_read += 1;
9539 next_offset += envelope_size;
9540 }
9541
9542 let next_out_of_line = decoder.next_out_of_line();
9543 let handles_before = decoder.remaining_handles();
9544 if let Some((inlined, num_bytes, num_handles)) =
9545 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9546 {
9547 let member_inline_size =
9548 <CisEstablishedParameters as fidl::encoding::TypeMarker>::inline_size(
9549 decoder.context,
9550 );
9551 if inlined != (member_inline_size <= 4) {
9552 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9553 }
9554 let inner_offset;
9555 let mut inner_depth = depth.clone();
9556 if inlined {
9557 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9558 inner_offset = next_offset;
9559 } else {
9560 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9561 inner_depth.increment()?;
9562 }
9563 let val_ref = self
9564 .established_params
9565 .get_or_insert_with(|| fidl::new_empty!(CisEstablishedParameters, D));
9566 fidl::decode!(
9567 CisEstablishedParameters,
9568 D,
9569 val_ref,
9570 decoder,
9571 inner_offset,
9572 inner_depth
9573 )?;
9574 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9575 {
9576 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9577 }
9578 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9579 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9580 }
9581 }
9582
9583 next_offset += envelope_size;
9584
9585 while next_offset < end_offset {
9587 _next_ordinal_to_read += 1;
9588 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9589 next_offset += envelope_size;
9590 }
9591
9592 Ok(())
9593 }
9594 }
9595
9596 impl IsochronousStreamSetupDataPathRequest {
9597 #[inline(always)]
9598 fn max_ordinal_present(&self) -> u64 {
9599 if let Some(_) = self.controller_delay {
9600 return 3;
9601 }
9602 if let Some(_) = self.codec_attributes {
9603 return 2;
9604 }
9605 if let Some(_) = self.data_direction {
9606 return 1;
9607 }
9608 0
9609 }
9610 }
9611
9612 impl fidl::encoding::ValueTypeMarker for IsochronousStreamSetupDataPathRequest {
9613 type Borrowed<'a> = &'a Self;
9614 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9615 value
9616 }
9617 }
9618
9619 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamSetupDataPathRequest {
9620 type Owned = Self;
9621
9622 #[inline(always)]
9623 fn inline_align(_context: fidl::encoding::Context) -> usize {
9624 8
9625 }
9626
9627 #[inline(always)]
9628 fn inline_size(_context: fidl::encoding::Context) -> usize {
9629 16
9630 }
9631 }
9632
9633 unsafe impl<D: fidl::encoding::ResourceDialect>
9634 fidl::encoding::Encode<IsochronousStreamSetupDataPathRequest, D>
9635 for &IsochronousStreamSetupDataPathRequest
9636 {
9637 unsafe fn encode(
9638 self,
9639 encoder: &mut fidl::encoding::Encoder<'_, D>,
9640 offset: usize,
9641 mut depth: fidl::encoding::Depth,
9642 ) -> fidl::Result<()> {
9643 encoder.debug_check_bounds::<IsochronousStreamSetupDataPathRequest>(offset);
9644 let max_ordinal: u64 = self.max_ordinal_present();
9646 encoder.write_num(max_ordinal, offset);
9647 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9648 if max_ordinal == 0 {
9650 return Ok(());
9651 }
9652 depth.increment()?;
9653 let envelope_size = 8;
9654 let bytes_len = max_ordinal as usize * envelope_size;
9655 #[allow(unused_variables)]
9656 let offset = encoder.out_of_line_offset(bytes_len);
9657 let mut _prev_end_offset: usize = 0;
9658 if 1 > max_ordinal {
9659 return Ok(());
9660 }
9661
9662 let cur_offset: usize = (1 - 1) * envelope_size;
9665
9666 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9668
9669 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
9674 self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
9675 encoder, offset + cur_offset, depth
9676 )?;
9677
9678 _prev_end_offset = cur_offset + envelope_size;
9679 if 2 > max_ordinal {
9680 return Ok(());
9681 }
9682
9683 let cur_offset: usize = (2 - 1) * envelope_size;
9686
9687 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9689
9690 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
9695 self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
9696 encoder, offset + cur_offset, depth
9697 )?;
9698
9699 _prev_end_offset = cur_offset + envelope_size;
9700 if 3 > max_ordinal {
9701 return Ok(());
9702 }
9703
9704 let cur_offset: usize = (3 - 1) * envelope_size;
9707
9708 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9710
9711 fidl::encoding::encode_in_envelope_optional::<i64, D>(
9716 self.controller_delay
9717 .as_ref()
9718 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9719 encoder,
9720 offset + cur_offset,
9721 depth,
9722 )?;
9723
9724 _prev_end_offset = cur_offset + envelope_size;
9725
9726 Ok(())
9727 }
9728 }
9729
9730 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9731 for IsochronousStreamSetupDataPathRequest
9732 {
9733 #[inline(always)]
9734 fn new_empty() -> Self {
9735 Self::default()
9736 }
9737
9738 unsafe fn decode(
9739 &mut self,
9740 decoder: &mut fidl::encoding::Decoder<'_, D>,
9741 offset: usize,
9742 mut depth: fidl::encoding::Depth,
9743 ) -> fidl::Result<()> {
9744 decoder.debug_check_bounds::<Self>(offset);
9745 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9746 None => return Err(fidl::Error::NotNullable),
9747 Some(len) => len,
9748 };
9749 if len == 0 {
9751 return Ok(());
9752 };
9753 depth.increment()?;
9754 let envelope_size = 8;
9755 let bytes_len = len * envelope_size;
9756 let offset = decoder.out_of_line_offset(bytes_len)?;
9757 let mut _next_ordinal_to_read = 0;
9759 let mut next_offset = offset;
9760 let end_offset = offset + bytes_len;
9761 _next_ordinal_to_read += 1;
9762 if next_offset >= end_offset {
9763 return Ok(());
9764 }
9765
9766 while _next_ordinal_to_read < 1 {
9768 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9769 _next_ordinal_to_read += 1;
9770 next_offset += envelope_size;
9771 }
9772
9773 let next_out_of_line = decoder.next_out_of_line();
9774 let handles_before = decoder.remaining_handles();
9775 if let Some((inlined, num_bytes, num_handles)) =
9776 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9777 {
9778 let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9779 if inlined != (member_inline_size <= 4) {
9780 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9781 }
9782 let inner_offset;
9783 let mut inner_depth = depth.clone();
9784 if inlined {
9785 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9786 inner_offset = next_offset;
9787 } else {
9788 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9789 inner_depth.increment()?;
9790 }
9791 let val_ref = self.data_direction.get_or_insert_with(|| {
9792 fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
9793 });
9794 fidl::decode!(
9795 fidl_fuchsia_bluetooth__common::DataDirection,
9796 D,
9797 val_ref,
9798 decoder,
9799 inner_offset,
9800 inner_depth
9801 )?;
9802 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9803 {
9804 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9805 }
9806 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9807 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9808 }
9809 }
9810
9811 next_offset += envelope_size;
9812 _next_ordinal_to_read += 1;
9813 if next_offset >= end_offset {
9814 return Ok(());
9815 }
9816
9817 while _next_ordinal_to_read < 2 {
9819 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9820 _next_ordinal_to_read += 1;
9821 next_offset += envelope_size;
9822 }
9823
9824 let next_out_of_line = decoder.next_out_of_line();
9825 let handles_before = decoder.remaining_handles();
9826 if let Some((inlined, num_bytes, num_handles)) =
9827 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9828 {
9829 let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9830 if inlined != (member_inline_size <= 4) {
9831 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9832 }
9833 let inner_offset;
9834 let mut inner_depth = depth.clone();
9835 if inlined {
9836 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9837 inner_offset = next_offset;
9838 } else {
9839 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9840 inner_depth.increment()?;
9841 }
9842 let val_ref = self.codec_attributes.get_or_insert_with(|| {
9843 fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
9844 });
9845 fidl::decode!(
9846 fidl_fuchsia_bluetooth__common::CodecAttributes,
9847 D,
9848 val_ref,
9849 decoder,
9850 inner_offset,
9851 inner_depth
9852 )?;
9853 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9854 {
9855 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9856 }
9857 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9858 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9859 }
9860 }
9861
9862 next_offset += envelope_size;
9863 _next_ordinal_to_read += 1;
9864 if next_offset >= end_offset {
9865 return Ok(());
9866 }
9867
9868 while _next_ordinal_to_read < 3 {
9870 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9871 _next_ordinal_to_read += 1;
9872 next_offset += envelope_size;
9873 }
9874
9875 let next_out_of_line = decoder.next_out_of_line();
9876 let handles_before = decoder.remaining_handles();
9877 if let Some((inlined, num_bytes, num_handles)) =
9878 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9879 {
9880 let member_inline_size =
9881 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9882 if inlined != (member_inline_size <= 4) {
9883 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9884 }
9885 let inner_offset;
9886 let mut inner_depth = depth.clone();
9887 if inlined {
9888 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9889 inner_offset = next_offset;
9890 } else {
9891 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9892 inner_depth.increment()?;
9893 }
9894 let val_ref = self.controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
9895 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9896 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9897 {
9898 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9899 }
9900 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9901 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9902 }
9903 }
9904
9905 next_offset += envelope_size;
9906
9907 while next_offset < end_offset {
9909 _next_ordinal_to_read += 1;
9910 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9911 next_offset += envelope_size;
9912 }
9913
9914 Ok(())
9915 }
9916 }
9917
9918 impl IsochronousStreamWriteRequest {
9919 #[inline(always)]
9920 fn max_ordinal_present(&self) -> u64 {
9921 if let Some(_) = self.data {
9922 return 1;
9923 }
9924 0
9925 }
9926 }
9927
9928 impl fidl::encoding::ValueTypeMarker for IsochronousStreamWriteRequest {
9929 type Borrowed<'a> = &'a Self;
9930 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9931 value
9932 }
9933 }
9934
9935 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamWriteRequest {
9936 type Owned = Self;
9937
9938 #[inline(always)]
9939 fn inline_align(_context: fidl::encoding::Context) -> usize {
9940 8
9941 }
9942
9943 #[inline(always)]
9944 fn inline_size(_context: fidl::encoding::Context) -> usize {
9945 16
9946 }
9947 }
9948
9949 unsafe impl<D: fidl::encoding::ResourceDialect>
9950 fidl::encoding::Encode<IsochronousStreamWriteRequest, D>
9951 for &IsochronousStreamWriteRequest
9952 {
9953 unsafe fn encode(
9954 self,
9955 encoder: &mut fidl::encoding::Encoder<'_, D>,
9956 offset: usize,
9957 mut depth: fidl::encoding::Depth,
9958 ) -> fidl::Result<()> {
9959 encoder.debug_check_bounds::<IsochronousStreamWriteRequest>(offset);
9960 let max_ordinal: u64 = self.max_ordinal_present();
9962 encoder.write_num(max_ordinal, offset);
9963 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9964 if max_ordinal == 0 {
9966 return Ok(());
9967 }
9968 depth.increment()?;
9969 let envelope_size = 8;
9970 let bytes_len = max_ordinal as usize * envelope_size;
9971 #[allow(unused_variables)]
9972 let offset = encoder.out_of_line_offset(bytes_len);
9973 let mut _prev_end_offset: usize = 0;
9974 if 1 > max_ordinal {
9975 return Ok(());
9976 }
9977
9978 let cur_offset: usize = (1 - 1) * envelope_size;
9981
9982 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9984
9985 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4095>, D>(
9990 self.data.as_ref().map(
9991 <fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow,
9992 ),
9993 encoder,
9994 offset + cur_offset,
9995 depth,
9996 )?;
9997
9998 _prev_end_offset = cur_offset + envelope_size;
9999
10000 Ok(())
10001 }
10002 }
10003
10004 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10005 for IsochronousStreamWriteRequest
10006 {
10007 #[inline(always)]
10008 fn new_empty() -> Self {
10009 Self::default()
10010 }
10011
10012 unsafe fn decode(
10013 &mut self,
10014 decoder: &mut fidl::encoding::Decoder<'_, D>,
10015 offset: usize,
10016 mut depth: fidl::encoding::Depth,
10017 ) -> fidl::Result<()> {
10018 decoder.debug_check_bounds::<Self>(offset);
10019 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10020 None => return Err(fidl::Error::NotNullable),
10021 Some(len) => len,
10022 };
10023 if len == 0 {
10025 return Ok(());
10026 };
10027 depth.increment()?;
10028 let envelope_size = 8;
10029 let bytes_len = len * envelope_size;
10030 let offset = decoder.out_of_line_offset(bytes_len)?;
10031 let mut _next_ordinal_to_read = 0;
10033 let mut next_offset = offset;
10034 let end_offset = offset + bytes_len;
10035 _next_ordinal_to_read += 1;
10036 if next_offset >= end_offset {
10037 return Ok(());
10038 }
10039
10040 while _next_ordinal_to_read < 1 {
10042 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10043 _next_ordinal_to_read += 1;
10044 next_offset += envelope_size;
10045 }
10046
10047 let next_out_of_line = decoder.next_out_of_line();
10048 let handles_before = decoder.remaining_handles();
10049 if let Some((inlined, num_bytes, num_handles)) =
10050 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10051 {
10052 let member_inline_size =
10053 <fidl::encoding::Vector<u8, 4095> as fidl::encoding::TypeMarker>::inline_size(
10054 decoder.context,
10055 );
10056 if inlined != (member_inline_size <= 4) {
10057 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10058 }
10059 let inner_offset;
10060 let mut inner_depth = depth.clone();
10061 if inlined {
10062 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10063 inner_offset = next_offset;
10064 } else {
10065 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10066 inner_depth.increment()?;
10067 }
10068 let val_ref = self
10069 .data
10070 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D));
10071 fidl::decode!(fidl::encoding::Vector<u8, 4095>, D, val_ref, decoder, inner_offset, inner_depth)?;
10072 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10073 {
10074 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10075 }
10076 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10077 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10078 }
10079 }
10080
10081 next_offset += envelope_size;
10082
10083 while next_offset < end_offset {
10085 _next_ordinal_to_read += 1;
10086 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10087 next_offset += envelope_size;
10088 }
10089
10090 Ok(())
10091 }
10092 }
10093
10094 impl IsochronousStreamReadResponse {
10095 #[inline(always)]
10096 fn max_ordinal_present(&self) -> u64 {
10097 if let Some(_) = self.timestamp {
10098 return 4;
10099 }
10100 if let Some(_) = self.status_flag {
10101 return 3;
10102 }
10103 if let Some(_) = self.sequence_number {
10104 return 2;
10105 }
10106 if let Some(_) = self.data {
10107 return 1;
10108 }
10109 0
10110 }
10111 }
10112
10113 impl fidl::encoding::ValueTypeMarker for IsochronousStreamReadResponse {
10114 type Borrowed<'a> = &'a Self;
10115 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10116 value
10117 }
10118 }
10119
10120 unsafe impl fidl::encoding::TypeMarker for IsochronousStreamReadResponse {
10121 type Owned = Self;
10122
10123 #[inline(always)]
10124 fn inline_align(_context: fidl::encoding::Context) -> usize {
10125 8
10126 }
10127
10128 #[inline(always)]
10129 fn inline_size(_context: fidl::encoding::Context) -> usize {
10130 16
10131 }
10132 }
10133
10134 unsafe impl<D: fidl::encoding::ResourceDialect>
10135 fidl::encoding::Encode<IsochronousStreamReadResponse, D>
10136 for &IsochronousStreamReadResponse
10137 {
10138 unsafe fn encode(
10139 self,
10140 encoder: &mut fidl::encoding::Encoder<'_, D>,
10141 offset: usize,
10142 mut depth: fidl::encoding::Depth,
10143 ) -> fidl::Result<()> {
10144 encoder.debug_check_bounds::<IsochronousStreamReadResponse>(offset);
10145 let max_ordinal: u64 = self.max_ordinal_present();
10147 encoder.write_num(max_ordinal, offset);
10148 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10149 if max_ordinal == 0 {
10151 return Ok(());
10152 }
10153 depth.increment()?;
10154 let envelope_size = 8;
10155 let bytes_len = max_ordinal as usize * envelope_size;
10156 #[allow(unused_variables)]
10157 let offset = encoder.out_of_line_offset(bytes_len);
10158 let mut _prev_end_offset: usize = 0;
10159 if 1 > max_ordinal {
10160 return Ok(());
10161 }
10162
10163 let cur_offset: usize = (1 - 1) * envelope_size;
10166
10167 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10169
10170 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10175 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10176 encoder, offset + cur_offset, depth
10177 )?;
10178
10179 _prev_end_offset = cur_offset + envelope_size;
10180 if 2 > max_ordinal {
10181 return Ok(());
10182 }
10183
10184 let cur_offset: usize = (2 - 1) * envelope_size;
10187
10188 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10190
10191 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10196 self.sequence_number.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10197 encoder,
10198 offset + cur_offset,
10199 depth,
10200 )?;
10201
10202 _prev_end_offset = cur_offset + envelope_size;
10203 if 3 > max_ordinal {
10204 return Ok(());
10205 }
10206
10207 let cur_offset: usize = (3 - 1) * envelope_size;
10210
10211 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10213
10214 fidl::encoding::encode_in_envelope_optional::<IsoPacketStatusFlag, D>(
10219 self.status_flag
10220 .as_ref()
10221 .map(<IsoPacketStatusFlag as fidl::encoding::ValueTypeMarker>::borrow),
10222 encoder,
10223 offset + cur_offset,
10224 depth,
10225 )?;
10226
10227 _prev_end_offset = cur_offset + envelope_size;
10228 if 4 > max_ordinal {
10229 return Ok(());
10230 }
10231
10232 let cur_offset: usize = (4 - 1) * envelope_size;
10235
10236 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10238
10239 fidl::encoding::encode_in_envelope_optional::<i64, D>(
10244 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10245 encoder,
10246 offset + cur_offset,
10247 depth,
10248 )?;
10249
10250 _prev_end_offset = cur_offset + envelope_size;
10251
10252 Ok(())
10253 }
10254 }
10255
10256 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10257 for IsochronousStreamReadResponse
10258 {
10259 #[inline(always)]
10260 fn new_empty() -> Self {
10261 Self::default()
10262 }
10263
10264 unsafe fn decode(
10265 &mut self,
10266 decoder: &mut fidl::encoding::Decoder<'_, D>,
10267 offset: usize,
10268 mut depth: fidl::encoding::Depth,
10269 ) -> fidl::Result<()> {
10270 decoder.debug_check_bounds::<Self>(offset);
10271 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10272 None => return Err(fidl::Error::NotNullable),
10273 Some(len) => len,
10274 };
10275 if len == 0 {
10277 return Ok(());
10278 };
10279 depth.increment()?;
10280 let envelope_size = 8;
10281 let bytes_len = len * envelope_size;
10282 let offset = decoder.out_of_line_offset(bytes_len)?;
10283 let mut _next_ordinal_to_read = 0;
10285 let mut next_offset = offset;
10286 let end_offset = offset + bytes_len;
10287 _next_ordinal_to_read += 1;
10288 if next_offset >= end_offset {
10289 return Ok(());
10290 }
10291
10292 while _next_ordinal_to_read < 1 {
10294 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10295 _next_ordinal_to_read += 1;
10296 next_offset += envelope_size;
10297 }
10298
10299 let next_out_of_line = decoder.next_out_of_line();
10300 let handles_before = decoder.remaining_handles();
10301 if let Some((inlined, num_bytes, num_handles)) =
10302 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10303 {
10304 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10305 if inlined != (member_inline_size <= 4) {
10306 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10307 }
10308 let inner_offset;
10309 let mut inner_depth = depth.clone();
10310 if inlined {
10311 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10312 inner_offset = next_offset;
10313 } else {
10314 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10315 inner_depth.increment()?;
10316 }
10317 let val_ref = self.data.get_or_insert_with(|| {
10318 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10319 });
10320 fidl::decode!(
10321 fidl::encoding::UnboundedVector<u8>,
10322 D,
10323 val_ref,
10324 decoder,
10325 inner_offset,
10326 inner_depth
10327 )?;
10328 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10329 {
10330 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10331 }
10332 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10333 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10334 }
10335 }
10336
10337 next_offset += envelope_size;
10338 _next_ordinal_to_read += 1;
10339 if next_offset >= end_offset {
10340 return Ok(());
10341 }
10342
10343 while _next_ordinal_to_read < 2 {
10345 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10346 _next_ordinal_to_read += 1;
10347 next_offset += envelope_size;
10348 }
10349
10350 let next_out_of_line = decoder.next_out_of_line();
10351 let handles_before = decoder.remaining_handles();
10352 if let Some((inlined, num_bytes, num_handles)) =
10353 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10354 {
10355 let member_inline_size =
10356 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10357 if inlined != (member_inline_size <= 4) {
10358 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10359 }
10360 let inner_offset;
10361 let mut inner_depth = depth.clone();
10362 if inlined {
10363 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10364 inner_offset = next_offset;
10365 } else {
10366 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10367 inner_depth.increment()?;
10368 }
10369 let val_ref = self.sequence_number.get_or_insert_with(|| fidl::new_empty!(u16, D));
10370 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10371 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10372 {
10373 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10374 }
10375 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10376 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10377 }
10378 }
10379
10380 next_offset += envelope_size;
10381 _next_ordinal_to_read += 1;
10382 if next_offset >= end_offset {
10383 return Ok(());
10384 }
10385
10386 while _next_ordinal_to_read < 3 {
10388 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10389 _next_ordinal_to_read += 1;
10390 next_offset += envelope_size;
10391 }
10392
10393 let next_out_of_line = decoder.next_out_of_line();
10394 let handles_before = decoder.remaining_handles();
10395 if let Some((inlined, num_bytes, num_handles)) =
10396 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10397 {
10398 let member_inline_size =
10399 <IsoPacketStatusFlag as fidl::encoding::TypeMarker>::inline_size(
10400 decoder.context,
10401 );
10402 if inlined != (member_inline_size <= 4) {
10403 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10404 }
10405 let inner_offset;
10406 let mut inner_depth = depth.clone();
10407 if inlined {
10408 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10409 inner_offset = next_offset;
10410 } else {
10411 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10412 inner_depth.increment()?;
10413 }
10414 let val_ref = self
10415 .status_flag
10416 .get_or_insert_with(|| fidl::new_empty!(IsoPacketStatusFlag, D));
10417 fidl::decode!(IsoPacketStatusFlag, D, val_ref, decoder, inner_offset, inner_depth)?;
10418 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10419 {
10420 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10421 }
10422 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10423 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10424 }
10425 }
10426
10427 next_offset += envelope_size;
10428 _next_ordinal_to_read += 1;
10429 if next_offset >= end_offset {
10430 return Ok(());
10431 }
10432
10433 while _next_ordinal_to_read < 4 {
10435 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10436 _next_ordinal_to_read += 1;
10437 next_offset += envelope_size;
10438 }
10439
10440 let next_out_of_line = decoder.next_out_of_line();
10441 let handles_before = decoder.remaining_handles();
10442 if let Some((inlined, num_bytes, num_handles)) =
10443 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10444 {
10445 let member_inline_size =
10446 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10447 if inlined != (member_inline_size <= 4) {
10448 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10449 }
10450 let inner_offset;
10451 let mut inner_depth = depth.clone();
10452 if inlined {
10453 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10454 inner_offset = next_offset;
10455 } else {
10456 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10457 inner_depth.increment()?;
10458 }
10459 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
10460 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
10461 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10462 {
10463 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10464 }
10465 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10466 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10467 }
10468 }
10469
10470 next_offset += envelope_size;
10471
10472 while next_offset < end_offset {
10474 _next_ordinal_to_read += 1;
10475 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10476 next_offset += envelope_size;
10477 }
10478
10479 Ok(())
10480 }
10481 }
10482
10483 impl Legacy {
10484 #[inline(always)]
10485 fn max_ordinal_present(&self) -> u64 {
10486 0
10487 }
10488 }
10489
10490 impl fidl::encoding::ValueTypeMarker for Legacy {
10491 type Borrowed<'a> = &'a Self;
10492 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10493 value
10494 }
10495 }
10496
10497 unsafe impl fidl::encoding::TypeMarker for Legacy {
10498 type Owned = Self;
10499
10500 #[inline(always)]
10501 fn inline_align(_context: fidl::encoding::Context) -> usize {
10502 8
10503 }
10504
10505 #[inline(always)]
10506 fn inline_size(_context: fidl::encoding::Context) -> usize {
10507 16
10508 }
10509 }
10510
10511 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Legacy, D> for &Legacy {
10512 unsafe fn encode(
10513 self,
10514 encoder: &mut fidl::encoding::Encoder<'_, D>,
10515 offset: usize,
10516 mut depth: fidl::encoding::Depth,
10517 ) -> fidl::Result<()> {
10518 encoder.debug_check_bounds::<Legacy>(offset);
10519 let max_ordinal: u64 = self.max_ordinal_present();
10521 encoder.write_num(max_ordinal, offset);
10522 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10523 if max_ordinal == 0 {
10525 return Ok(());
10526 }
10527 depth.increment()?;
10528 let envelope_size = 8;
10529 let bytes_len = max_ordinal as usize * envelope_size;
10530 #[allow(unused_variables)]
10531 let offset = encoder.out_of_line_offset(bytes_len);
10532 let mut _prev_end_offset: usize = 0;
10533
10534 Ok(())
10535 }
10536 }
10537
10538 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Legacy {
10539 #[inline(always)]
10540 fn new_empty() -> Self {
10541 Self::default()
10542 }
10543
10544 unsafe fn decode(
10545 &mut self,
10546 decoder: &mut fidl::encoding::Decoder<'_, D>,
10547 offset: usize,
10548 mut depth: fidl::encoding::Depth,
10549 ) -> fidl::Result<()> {
10550 decoder.debug_check_bounds::<Self>(offset);
10551 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10552 None => return Err(fidl::Error::NotNullable),
10553 Some(len) => len,
10554 };
10555 if len == 0 {
10557 return Ok(());
10558 };
10559 depth.increment()?;
10560 let envelope_size = 8;
10561 let bytes_len = len * envelope_size;
10562 let offset = decoder.out_of_line_offset(bytes_len)?;
10563 let mut _next_ordinal_to_read = 0;
10565 let mut next_offset = offset;
10566 let end_offset = offset + bytes_len;
10567
10568 while next_offset < end_offset {
10570 _next_ordinal_to_read += 1;
10571 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10572 next_offset += envelope_size;
10573 }
10574
10575 Ok(())
10576 }
10577 }
10578
10579 impl Peer {
10580 #[inline(always)]
10581 fn max_ordinal_present(&self) -> u64 {
10582 if let Some(_) = self.periodic_advertising_interval {
10583 return 10;
10584 }
10585 if let Some(_) = self.advertising_sid {
10586 return 9;
10587 }
10588 if let Some(_) = self.last_updated {
10589 return 8;
10590 }
10591 if let Some(_) = self.bonded {
10592 return 7;
10593 }
10594 if let Some(_) = self.data {
10595 return 6;
10596 }
10597 if let Some(_) = self.name {
10598 return 5;
10599 }
10600 if let Some(_) = self.advertising_data {
10601 return 4;
10602 }
10603 if let Some(_) = self.rssi {
10604 return 3;
10605 }
10606 if let Some(_) = self.connectable {
10607 return 2;
10608 }
10609 if let Some(_) = self.id {
10610 return 1;
10611 }
10612 0
10613 }
10614 }
10615
10616 impl fidl::encoding::ValueTypeMarker for Peer {
10617 type Borrowed<'a> = &'a Self;
10618 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10619 value
10620 }
10621 }
10622
10623 unsafe impl fidl::encoding::TypeMarker for Peer {
10624 type Owned = Self;
10625
10626 #[inline(always)]
10627 fn inline_align(_context: fidl::encoding::Context) -> usize {
10628 8
10629 }
10630
10631 #[inline(always)]
10632 fn inline_size(_context: fidl::encoding::Context) -> usize {
10633 16
10634 }
10635 }
10636
10637 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Peer, D> for &Peer {
10638 unsafe fn encode(
10639 self,
10640 encoder: &mut fidl::encoding::Encoder<'_, D>,
10641 offset: usize,
10642 mut depth: fidl::encoding::Depth,
10643 ) -> fidl::Result<()> {
10644 encoder.debug_check_bounds::<Peer>(offset);
10645 let max_ordinal: u64 = self.max_ordinal_present();
10647 encoder.write_num(max_ordinal, offset);
10648 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10649 if max_ordinal == 0 {
10651 return Ok(());
10652 }
10653 depth.increment()?;
10654 let envelope_size = 8;
10655 let bytes_len = max_ordinal as usize * envelope_size;
10656 #[allow(unused_variables)]
10657 let offset = encoder.out_of_line_offset(bytes_len);
10658 let mut _prev_end_offset: usize = 0;
10659 if 1 > max_ordinal {
10660 return Ok(());
10661 }
10662
10663 let cur_offset: usize = (1 - 1) * envelope_size;
10666
10667 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10669
10670 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
10675 self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
10676 encoder, offset + cur_offset, depth
10677 )?;
10678
10679 _prev_end_offset = cur_offset + envelope_size;
10680 if 2 > max_ordinal {
10681 return Ok(());
10682 }
10683
10684 let cur_offset: usize = (2 - 1) * envelope_size;
10687
10688 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10690
10691 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10696 self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10697 encoder,
10698 offset + cur_offset,
10699 depth,
10700 )?;
10701
10702 _prev_end_offset = cur_offset + envelope_size;
10703 if 3 > max_ordinal {
10704 return Ok(());
10705 }
10706
10707 let cur_offset: usize = (3 - 1) * envelope_size;
10710
10711 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10713
10714 fidl::encoding::encode_in_envelope_optional::<i8, D>(
10719 self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10720 encoder,
10721 offset + cur_offset,
10722 depth,
10723 )?;
10724
10725 _prev_end_offset = cur_offset + envelope_size;
10726 if 4 > max_ordinal {
10727 return Ok(());
10728 }
10729
10730 let cur_offset: usize = (4 - 1) * envelope_size;
10733
10734 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10736
10737 fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
10742 self.advertising_data
10743 .as_ref()
10744 .map(<AdvertisingData 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 5 > max_ordinal {
10752 return Ok(());
10753 }
10754
10755 let cur_offset: usize = (5 - 1) * envelope_size;
10758
10759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10761
10762 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
10767 self.name.as_ref().map(
10768 <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
10769 ),
10770 encoder,
10771 offset + cur_offset,
10772 depth,
10773 )?;
10774
10775 _prev_end_offset = cur_offset + envelope_size;
10776 if 6 > max_ordinal {
10777 return Ok(());
10778 }
10779
10780 let cur_offset: usize = (6 - 1) * envelope_size;
10783
10784 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10786
10787 fidl::encoding::encode_in_envelope_optional::<ScanData, D>(
10792 self.data.as_ref().map(<ScanData as fidl::encoding::ValueTypeMarker>::borrow),
10793 encoder,
10794 offset + cur_offset,
10795 depth,
10796 )?;
10797
10798 _prev_end_offset = cur_offset + envelope_size;
10799 if 7 > max_ordinal {
10800 return Ok(());
10801 }
10802
10803 let cur_offset: usize = (7 - 1) * envelope_size;
10806
10807 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10809
10810 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10815 self.bonded.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10816 encoder,
10817 offset + cur_offset,
10818 depth,
10819 )?;
10820
10821 _prev_end_offset = cur_offset + envelope_size;
10822 if 8 > max_ordinal {
10823 return Ok(());
10824 }
10825
10826 let cur_offset: usize = (8 - 1) * envelope_size;
10829
10830 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10832
10833 fidl::encoding::encode_in_envelope_optional::<i64, D>(
10838 self.last_updated.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10839 encoder,
10840 offset + cur_offset,
10841 depth,
10842 )?;
10843
10844 _prev_end_offset = cur_offset + envelope_size;
10845 if 9 > max_ordinal {
10846 return Ok(());
10847 }
10848
10849 let cur_offset: usize = (9 - 1) * envelope_size;
10852
10853 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10855
10856 fidl::encoding::encode_in_envelope_optional::<u8, D>(
10861 self.advertising_sid.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
10862 encoder,
10863 offset + cur_offset,
10864 depth,
10865 )?;
10866
10867 _prev_end_offset = cur_offset + envelope_size;
10868 if 10 > max_ordinal {
10869 return Ok(());
10870 }
10871
10872 let cur_offset: usize = (10 - 1) * envelope_size;
10875
10876 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10878
10879 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10884 self.periodic_advertising_interval
10885 .as_ref()
10886 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10887 encoder,
10888 offset + cur_offset,
10889 depth,
10890 )?;
10891
10892 _prev_end_offset = cur_offset + envelope_size;
10893
10894 Ok(())
10895 }
10896 }
10897
10898 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Peer {
10899 #[inline(always)]
10900 fn new_empty() -> Self {
10901 Self::default()
10902 }
10903
10904 unsafe fn decode(
10905 &mut self,
10906 decoder: &mut fidl::encoding::Decoder<'_, D>,
10907 offset: usize,
10908 mut depth: fidl::encoding::Depth,
10909 ) -> fidl::Result<()> {
10910 decoder.debug_check_bounds::<Self>(offset);
10911 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10912 None => return Err(fidl::Error::NotNullable),
10913 Some(len) => len,
10914 };
10915 if len == 0 {
10917 return Ok(());
10918 };
10919 depth.increment()?;
10920 let envelope_size = 8;
10921 let bytes_len = len * envelope_size;
10922 let offset = decoder.out_of_line_offset(bytes_len)?;
10923 let mut _next_ordinal_to_read = 0;
10925 let mut next_offset = offset;
10926 let end_offset = offset + bytes_len;
10927 _next_ordinal_to_read += 1;
10928 if next_offset >= end_offset {
10929 return Ok(());
10930 }
10931
10932 while _next_ordinal_to_read < 1 {
10934 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10935 _next_ordinal_to_read += 1;
10936 next_offset += envelope_size;
10937 }
10938
10939 let next_out_of_line = decoder.next_out_of_line();
10940 let handles_before = decoder.remaining_handles();
10941 if let Some((inlined, num_bytes, num_handles)) =
10942 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10943 {
10944 let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10945 if inlined != (member_inline_size <= 4) {
10946 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10947 }
10948 let inner_offset;
10949 let mut inner_depth = depth.clone();
10950 if inlined {
10951 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10952 inner_offset = next_offset;
10953 } else {
10954 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10955 inner_depth.increment()?;
10956 }
10957 let val_ref = self.id.get_or_insert_with(|| {
10958 fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
10959 });
10960 fidl::decode!(
10961 fidl_fuchsia_bluetooth__common::PeerId,
10962 D,
10963 val_ref,
10964 decoder,
10965 inner_offset,
10966 inner_depth
10967 )?;
10968 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10969 {
10970 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10971 }
10972 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10973 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10974 }
10975 }
10976
10977 next_offset += envelope_size;
10978 _next_ordinal_to_read += 1;
10979 if next_offset >= end_offset {
10980 return Ok(());
10981 }
10982
10983 while _next_ordinal_to_read < 2 {
10985 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10986 _next_ordinal_to_read += 1;
10987 next_offset += envelope_size;
10988 }
10989
10990 let next_out_of_line = decoder.next_out_of_line();
10991 let handles_before = decoder.remaining_handles();
10992 if let Some((inlined, num_bytes, num_handles)) =
10993 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10994 {
10995 let member_inline_size =
10996 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10997 if inlined != (member_inline_size <= 4) {
10998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10999 }
11000 let inner_offset;
11001 let mut inner_depth = depth.clone();
11002 if inlined {
11003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11004 inner_offset = next_offset;
11005 } else {
11006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11007 inner_depth.increment()?;
11008 }
11009 let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
11010 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11011 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11012 {
11013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11014 }
11015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11017 }
11018 }
11019
11020 next_offset += envelope_size;
11021 _next_ordinal_to_read += 1;
11022 if next_offset >= end_offset {
11023 return Ok(());
11024 }
11025
11026 while _next_ordinal_to_read < 3 {
11028 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11029 _next_ordinal_to_read += 1;
11030 next_offset += envelope_size;
11031 }
11032
11033 let next_out_of_line = decoder.next_out_of_line();
11034 let handles_before = decoder.remaining_handles();
11035 if let Some((inlined, num_bytes, num_handles)) =
11036 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11037 {
11038 let member_inline_size =
11039 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11040 if inlined != (member_inline_size <= 4) {
11041 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11042 }
11043 let inner_offset;
11044 let mut inner_depth = depth.clone();
11045 if inlined {
11046 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11047 inner_offset = next_offset;
11048 } else {
11049 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11050 inner_depth.increment()?;
11051 }
11052 let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
11053 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11054 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11055 {
11056 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11057 }
11058 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11059 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11060 }
11061 }
11062
11063 next_offset += envelope_size;
11064 _next_ordinal_to_read += 1;
11065 if next_offset >= end_offset {
11066 return Ok(());
11067 }
11068
11069 while _next_ordinal_to_read < 4 {
11071 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11072 _next_ordinal_to_read += 1;
11073 next_offset += envelope_size;
11074 }
11075
11076 let next_out_of_line = decoder.next_out_of_line();
11077 let handles_before = decoder.remaining_handles();
11078 if let Some((inlined, num_bytes, num_handles)) =
11079 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11080 {
11081 let member_inline_size =
11082 <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11083 if inlined != (member_inline_size <= 4) {
11084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11085 }
11086 let inner_offset;
11087 let mut inner_depth = depth.clone();
11088 if inlined {
11089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11090 inner_offset = next_offset;
11091 } else {
11092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11093 inner_depth.increment()?;
11094 }
11095 let val_ref = self
11096 .advertising_data
11097 .get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
11098 fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
11099 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11100 {
11101 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11102 }
11103 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11104 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11105 }
11106 }
11107
11108 next_offset += envelope_size;
11109 _next_ordinal_to_read += 1;
11110 if next_offset >= end_offset {
11111 return Ok(());
11112 }
11113
11114 while _next_ordinal_to_read < 5 {
11116 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11117 _next_ordinal_to_read += 1;
11118 next_offset += envelope_size;
11119 }
11120
11121 let next_out_of_line = decoder.next_out_of_line();
11122 let handles_before = decoder.remaining_handles();
11123 if let Some((inlined, num_bytes, num_handles)) =
11124 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11125 {
11126 let member_inline_size =
11127 <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
11128 decoder.context,
11129 );
11130 if inlined != (member_inline_size <= 4) {
11131 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11132 }
11133 let inner_offset;
11134 let mut inner_depth = depth.clone();
11135 if inlined {
11136 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11137 inner_offset = next_offset;
11138 } else {
11139 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11140 inner_depth.increment()?;
11141 }
11142 let val_ref = self
11143 .name
11144 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
11145 fidl::decode!(
11146 fidl::encoding::BoundedString<248>,
11147 D,
11148 val_ref,
11149 decoder,
11150 inner_offset,
11151 inner_depth
11152 )?;
11153 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11154 {
11155 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11156 }
11157 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11158 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11159 }
11160 }
11161
11162 next_offset += envelope_size;
11163 _next_ordinal_to_read += 1;
11164 if next_offset >= end_offset {
11165 return Ok(());
11166 }
11167
11168 while _next_ordinal_to_read < 6 {
11170 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11171 _next_ordinal_to_read += 1;
11172 next_offset += envelope_size;
11173 }
11174
11175 let next_out_of_line = decoder.next_out_of_line();
11176 let handles_before = decoder.remaining_handles();
11177 if let Some((inlined, num_bytes, num_handles)) =
11178 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11179 {
11180 let member_inline_size =
11181 <ScanData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11182 if inlined != (member_inline_size <= 4) {
11183 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11184 }
11185 let inner_offset;
11186 let mut inner_depth = depth.clone();
11187 if inlined {
11188 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11189 inner_offset = next_offset;
11190 } else {
11191 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11192 inner_depth.increment()?;
11193 }
11194 let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(ScanData, D));
11195 fidl::decode!(ScanData, D, val_ref, decoder, inner_offset, inner_depth)?;
11196 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11197 {
11198 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11199 }
11200 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11201 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11202 }
11203 }
11204
11205 next_offset += envelope_size;
11206 _next_ordinal_to_read += 1;
11207 if next_offset >= end_offset {
11208 return Ok(());
11209 }
11210
11211 while _next_ordinal_to_read < 7 {
11213 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11214 _next_ordinal_to_read += 1;
11215 next_offset += envelope_size;
11216 }
11217
11218 let next_out_of_line = decoder.next_out_of_line();
11219 let handles_before = decoder.remaining_handles();
11220 if let Some((inlined, num_bytes, num_handles)) =
11221 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11222 {
11223 let member_inline_size =
11224 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11225 if inlined != (member_inline_size <= 4) {
11226 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11227 }
11228 let inner_offset;
11229 let mut inner_depth = depth.clone();
11230 if inlined {
11231 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11232 inner_offset = next_offset;
11233 } else {
11234 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11235 inner_depth.increment()?;
11236 }
11237 let val_ref = self.bonded.get_or_insert_with(|| fidl::new_empty!(bool, D));
11238 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11239 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11240 {
11241 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11242 }
11243 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11244 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11245 }
11246 }
11247
11248 next_offset += envelope_size;
11249 _next_ordinal_to_read += 1;
11250 if next_offset >= end_offset {
11251 return Ok(());
11252 }
11253
11254 while _next_ordinal_to_read < 8 {
11256 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11257 _next_ordinal_to_read += 1;
11258 next_offset += envelope_size;
11259 }
11260
11261 let next_out_of_line = decoder.next_out_of_line();
11262 let handles_before = decoder.remaining_handles();
11263 if let Some((inlined, num_bytes, num_handles)) =
11264 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11265 {
11266 let member_inline_size =
11267 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11268 if inlined != (member_inline_size <= 4) {
11269 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11270 }
11271 let inner_offset;
11272 let mut inner_depth = depth.clone();
11273 if inlined {
11274 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11275 inner_offset = next_offset;
11276 } else {
11277 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11278 inner_depth.increment()?;
11279 }
11280 let val_ref = self.last_updated.get_or_insert_with(|| fidl::new_empty!(i64, D));
11281 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11282 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11283 {
11284 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11285 }
11286 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11287 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11288 }
11289 }
11290
11291 next_offset += envelope_size;
11292 _next_ordinal_to_read += 1;
11293 if next_offset >= end_offset {
11294 return Ok(());
11295 }
11296
11297 while _next_ordinal_to_read < 9 {
11299 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11300 _next_ordinal_to_read += 1;
11301 next_offset += envelope_size;
11302 }
11303
11304 let next_out_of_line = decoder.next_out_of_line();
11305 let handles_before = decoder.remaining_handles();
11306 if let Some((inlined, num_bytes, num_handles)) =
11307 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11308 {
11309 let member_inline_size =
11310 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11311 if inlined != (member_inline_size <= 4) {
11312 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11313 }
11314 let inner_offset;
11315 let mut inner_depth = depth.clone();
11316 if inlined {
11317 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11318 inner_offset = next_offset;
11319 } else {
11320 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11321 inner_depth.increment()?;
11322 }
11323 let val_ref = self.advertising_sid.get_or_insert_with(|| fidl::new_empty!(u8, D));
11324 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
11325 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11326 {
11327 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11328 }
11329 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11330 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11331 }
11332 }
11333
11334 next_offset += envelope_size;
11335 _next_ordinal_to_read += 1;
11336 if next_offset >= end_offset {
11337 return Ok(());
11338 }
11339
11340 while _next_ordinal_to_read < 10 {
11342 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11343 _next_ordinal_to_read += 1;
11344 next_offset += envelope_size;
11345 }
11346
11347 let next_out_of_line = decoder.next_out_of_line();
11348 let handles_before = decoder.remaining_handles();
11349 if let Some((inlined, num_bytes, num_handles)) =
11350 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11351 {
11352 let member_inline_size =
11353 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11354 if inlined != (member_inline_size <= 4) {
11355 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11356 }
11357 let inner_offset;
11358 let mut inner_depth = depth.clone();
11359 if inlined {
11360 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11361 inner_offset = next_offset;
11362 } else {
11363 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11364 inner_depth.increment()?;
11365 }
11366 let val_ref = self
11367 .periodic_advertising_interval
11368 .get_or_insert_with(|| fidl::new_empty!(u16, D));
11369 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11370 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11371 {
11372 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11373 }
11374 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11375 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11376 }
11377 }
11378
11379 next_offset += envelope_size;
11380
11381 while next_offset < end_offset {
11383 _next_ordinal_to_read += 1;
11384 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11385 next_offset += envelope_size;
11386 }
11387
11388 Ok(())
11389 }
11390 }
11391
11392 impl ScanData {
11393 #[inline(always)]
11394 fn max_ordinal_present(&self) -> u64 {
11395 if let Some(_) = self.timestamp {
11396 return 7;
11397 }
11398 if let Some(_) = self.uris {
11399 return 6;
11400 }
11401 if let Some(_) = self.manufacturer_data {
11402 return 5;
11403 }
11404 if let Some(_) = self.service_data {
11405 return 4;
11406 }
11407 if let Some(_) = self.service_uuids {
11408 return 3;
11409 }
11410 if let Some(_) = self.appearance {
11411 return 2;
11412 }
11413 if let Some(_) = self.tx_power {
11414 return 1;
11415 }
11416 0
11417 }
11418 }
11419
11420 impl fidl::encoding::ValueTypeMarker for ScanData {
11421 type Borrowed<'a> = &'a Self;
11422 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11423 value
11424 }
11425 }
11426
11427 unsafe impl fidl::encoding::TypeMarker for ScanData {
11428 type Owned = Self;
11429
11430 #[inline(always)]
11431 fn inline_align(_context: fidl::encoding::Context) -> usize {
11432 8
11433 }
11434
11435 #[inline(always)]
11436 fn inline_size(_context: fidl::encoding::Context) -> usize {
11437 16
11438 }
11439 }
11440
11441 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanData, D> for &ScanData {
11442 unsafe fn encode(
11443 self,
11444 encoder: &mut fidl::encoding::Encoder<'_, D>,
11445 offset: usize,
11446 mut depth: fidl::encoding::Depth,
11447 ) -> fidl::Result<()> {
11448 encoder.debug_check_bounds::<ScanData>(offset);
11449 let max_ordinal: u64 = self.max_ordinal_present();
11451 encoder.write_num(max_ordinal, offset);
11452 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11453 if max_ordinal == 0 {
11455 return Ok(());
11456 }
11457 depth.increment()?;
11458 let envelope_size = 8;
11459 let bytes_len = max_ordinal as usize * envelope_size;
11460 #[allow(unused_variables)]
11461 let offset = encoder.out_of_line_offset(bytes_len);
11462 let mut _prev_end_offset: usize = 0;
11463 if 1 > max_ordinal {
11464 return Ok(());
11465 }
11466
11467 let cur_offset: usize = (1 - 1) * envelope_size;
11470
11471 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11473
11474 fidl::encoding::encode_in_envelope_optional::<i8, D>(
11479 self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
11480 encoder,
11481 offset + cur_offset,
11482 depth,
11483 )?;
11484
11485 _prev_end_offset = cur_offset + envelope_size;
11486 if 2 > max_ordinal {
11487 return Ok(());
11488 }
11489
11490 let cur_offset: usize = (2 - 1) * envelope_size;
11493
11494 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11496
11497 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
11502 self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
11503 encoder, offset + cur_offset, depth
11504 )?;
11505
11506 _prev_end_offset = cur_offset + envelope_size;
11507 if 3 > max_ordinal {
11508 return Ok(());
11509 }
11510
11511 let cur_offset: usize = (3 - 1) * envelope_size;
11514
11515 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11517
11518 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
11523 self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
11524 encoder, offset + cur_offset, depth
11525 )?;
11526
11527 _prev_end_offset = cur_offset + envelope_size;
11528 if 4 > max_ordinal {
11529 return Ok(());
11530 }
11531
11532 let cur_offset: usize = (4 - 1) * envelope_size;
11535
11536 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11538
11539 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
11544 self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
11545 encoder, offset + cur_offset, depth
11546 )?;
11547
11548 _prev_end_offset = cur_offset + envelope_size;
11549 if 5 > max_ordinal {
11550 return Ok(());
11551 }
11552
11553 let cur_offset: usize = (5 - 1) * envelope_size;
11556
11557 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11559
11560 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
11565 self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
11566 encoder, offset + cur_offset, depth
11567 )?;
11568
11569 _prev_end_offset = cur_offset + envelope_size;
11570 if 6 > max_ordinal {
11571 return Ok(());
11572 }
11573
11574 let cur_offset: usize = (6 - 1) * envelope_size;
11577
11578 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11580
11581 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
11586 self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
11587 encoder, offset + cur_offset, depth
11588 )?;
11589
11590 _prev_end_offset = cur_offset + envelope_size;
11591 if 7 > max_ordinal {
11592 return Ok(());
11593 }
11594
11595 let cur_offset: usize = (7 - 1) * envelope_size;
11598
11599 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11601
11602 fidl::encoding::encode_in_envelope_optional::<i64, D>(
11607 self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
11608 encoder,
11609 offset + cur_offset,
11610 depth,
11611 )?;
11612
11613 _prev_end_offset = cur_offset + envelope_size;
11614
11615 Ok(())
11616 }
11617 }
11618
11619 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanData {
11620 #[inline(always)]
11621 fn new_empty() -> Self {
11622 Self::default()
11623 }
11624
11625 unsafe fn decode(
11626 &mut self,
11627 decoder: &mut fidl::encoding::Decoder<'_, D>,
11628 offset: usize,
11629 mut depth: fidl::encoding::Depth,
11630 ) -> fidl::Result<()> {
11631 decoder.debug_check_bounds::<Self>(offset);
11632 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11633 None => return Err(fidl::Error::NotNullable),
11634 Some(len) => len,
11635 };
11636 if len == 0 {
11638 return Ok(());
11639 };
11640 depth.increment()?;
11641 let envelope_size = 8;
11642 let bytes_len = len * envelope_size;
11643 let offset = decoder.out_of_line_offset(bytes_len)?;
11644 let mut _next_ordinal_to_read = 0;
11646 let mut next_offset = offset;
11647 let end_offset = offset + bytes_len;
11648 _next_ordinal_to_read += 1;
11649 if next_offset >= end_offset {
11650 return Ok(());
11651 }
11652
11653 while _next_ordinal_to_read < 1 {
11655 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11656 _next_ordinal_to_read += 1;
11657 next_offset += envelope_size;
11658 }
11659
11660 let next_out_of_line = decoder.next_out_of_line();
11661 let handles_before = decoder.remaining_handles();
11662 if let Some((inlined, num_bytes, num_handles)) =
11663 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11664 {
11665 let member_inline_size =
11666 <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11667 if inlined != (member_inline_size <= 4) {
11668 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11669 }
11670 let inner_offset;
11671 let mut inner_depth = depth.clone();
11672 if inlined {
11673 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11674 inner_offset = next_offset;
11675 } else {
11676 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11677 inner_depth.increment()?;
11678 }
11679 let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
11680 fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11681 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11682 {
11683 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11684 }
11685 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11686 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11687 }
11688 }
11689
11690 next_offset += envelope_size;
11691 _next_ordinal_to_read += 1;
11692 if next_offset >= end_offset {
11693 return Ok(());
11694 }
11695
11696 while _next_ordinal_to_read < 2 {
11698 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11699 _next_ordinal_to_read += 1;
11700 next_offset += envelope_size;
11701 }
11702
11703 let next_out_of_line = decoder.next_out_of_line();
11704 let handles_before = decoder.remaining_handles();
11705 if let Some((inlined, num_bytes, num_handles)) =
11706 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11707 {
11708 let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11709 if inlined != (member_inline_size <= 4) {
11710 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11711 }
11712 let inner_offset;
11713 let mut inner_depth = depth.clone();
11714 if inlined {
11715 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11716 inner_offset = next_offset;
11717 } else {
11718 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11719 inner_depth.increment()?;
11720 }
11721 let val_ref = self.appearance.get_or_insert_with(|| {
11722 fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
11723 });
11724 fidl::decode!(
11725 fidl_fuchsia_bluetooth__common::Appearance,
11726 D,
11727 val_ref,
11728 decoder,
11729 inner_offset,
11730 inner_depth
11731 )?;
11732 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11733 {
11734 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11735 }
11736 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11737 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11738 }
11739 }
11740
11741 next_offset += envelope_size;
11742 _next_ordinal_to_read += 1;
11743 if next_offset >= end_offset {
11744 return Ok(());
11745 }
11746
11747 while _next_ordinal_to_read < 3 {
11749 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11750 _next_ordinal_to_read += 1;
11751 next_offset += envelope_size;
11752 }
11753
11754 let next_out_of_line = decoder.next_out_of_line();
11755 let handles_before = decoder.remaining_handles();
11756 if let Some((inlined, num_bytes, num_handles)) =
11757 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11758 {
11759 let member_inline_size = <fidl::encoding::UnboundedVector<
11760 fidl_fuchsia_bluetooth__common::Uuid,
11761 > as fidl::encoding::TypeMarker>::inline_size(
11762 decoder.context
11763 );
11764 if inlined != (member_inline_size <= 4) {
11765 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11766 }
11767 let inner_offset;
11768 let mut inner_depth = depth.clone();
11769 if inlined {
11770 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11771 inner_offset = next_offset;
11772 } else {
11773 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11774 inner_depth.increment()?;
11775 }
11776 let val_ref = self.service_uuids.get_or_insert_with(|| {
11777 fidl::new_empty!(
11778 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11779 D
11780 )
11781 });
11782 fidl::decode!(
11783 fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11784 D,
11785 val_ref,
11786 decoder,
11787 inner_offset,
11788 inner_depth
11789 )?;
11790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11791 {
11792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11793 }
11794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11796 }
11797 }
11798
11799 next_offset += envelope_size;
11800 _next_ordinal_to_read += 1;
11801 if next_offset >= end_offset {
11802 return Ok(());
11803 }
11804
11805 while _next_ordinal_to_read < 4 {
11807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11808 _next_ordinal_to_read += 1;
11809 next_offset += envelope_size;
11810 }
11811
11812 let next_out_of_line = decoder.next_out_of_line();
11813 let handles_before = decoder.remaining_handles();
11814 if let Some((inlined, num_bytes, num_handles)) =
11815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11816 {
11817 let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11818 if inlined != (member_inline_size <= 4) {
11819 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11820 }
11821 let inner_offset;
11822 let mut inner_depth = depth.clone();
11823 if inlined {
11824 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11825 inner_offset = next_offset;
11826 } else {
11827 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11828 inner_depth.increment()?;
11829 }
11830 let val_ref = self.service_data.get_or_insert_with(|| {
11831 fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
11832 });
11833 fidl::decode!(
11834 fidl::encoding::UnboundedVector<ServiceData>,
11835 D,
11836 val_ref,
11837 decoder,
11838 inner_offset,
11839 inner_depth
11840 )?;
11841 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11842 {
11843 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11844 }
11845 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11846 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11847 }
11848 }
11849
11850 next_offset += envelope_size;
11851 _next_ordinal_to_read += 1;
11852 if next_offset >= end_offset {
11853 return Ok(());
11854 }
11855
11856 while _next_ordinal_to_read < 5 {
11858 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11859 _next_ordinal_to_read += 1;
11860 next_offset += envelope_size;
11861 }
11862
11863 let next_out_of_line = decoder.next_out_of_line();
11864 let handles_before = decoder.remaining_handles();
11865 if let Some((inlined, num_bytes, num_handles)) =
11866 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11867 {
11868 let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11869 if inlined != (member_inline_size <= 4) {
11870 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11871 }
11872 let inner_offset;
11873 let mut inner_depth = depth.clone();
11874 if inlined {
11875 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11876 inner_offset = next_offset;
11877 } else {
11878 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11879 inner_depth.increment()?;
11880 }
11881 let val_ref = self.manufacturer_data.get_or_insert_with(|| {
11882 fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
11883 });
11884 fidl::decode!(
11885 fidl::encoding::UnboundedVector<ManufacturerData>,
11886 D,
11887 val_ref,
11888 decoder,
11889 inner_offset,
11890 inner_depth
11891 )?;
11892 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11893 {
11894 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11895 }
11896 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11897 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11898 }
11899 }
11900
11901 next_offset += envelope_size;
11902 _next_ordinal_to_read += 1;
11903 if next_offset >= end_offset {
11904 return Ok(());
11905 }
11906
11907 while _next_ordinal_to_read < 6 {
11909 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11910 _next_ordinal_to_read += 1;
11911 next_offset += envelope_size;
11912 }
11913
11914 let next_out_of_line = decoder.next_out_of_line();
11915 let handles_before = decoder.remaining_handles();
11916 if let Some((inlined, num_bytes, num_handles)) =
11917 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11918 {
11919 let member_inline_size = <fidl::encoding::UnboundedVector<
11920 fidl::encoding::BoundedString<278>,
11921 > as fidl::encoding::TypeMarker>::inline_size(
11922 decoder.context
11923 );
11924 if inlined != (member_inline_size <= 4) {
11925 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11926 }
11927 let inner_offset;
11928 let mut inner_depth = depth.clone();
11929 if inlined {
11930 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11931 inner_offset = next_offset;
11932 } else {
11933 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11934 inner_depth.increment()?;
11935 }
11936 let val_ref = self.uris.get_or_insert_with(|| {
11937 fidl::new_empty!(
11938 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11939 D
11940 )
11941 });
11942 fidl::decode!(
11943 fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11944 D,
11945 val_ref,
11946 decoder,
11947 inner_offset,
11948 inner_depth
11949 )?;
11950 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11951 {
11952 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11953 }
11954 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11955 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11956 }
11957 }
11958
11959 next_offset += envelope_size;
11960 _next_ordinal_to_read += 1;
11961 if next_offset >= end_offset {
11962 return Ok(());
11963 }
11964
11965 while _next_ordinal_to_read < 7 {
11967 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11968 _next_ordinal_to_read += 1;
11969 next_offset += envelope_size;
11970 }
11971
11972 let next_out_of_line = decoder.next_out_of_line();
11973 let handles_before = decoder.remaining_handles();
11974 if let Some((inlined, num_bytes, num_handles)) =
11975 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11976 {
11977 let member_inline_size =
11978 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11979 if inlined != (member_inline_size <= 4) {
11980 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11981 }
11982 let inner_offset;
11983 let mut inner_depth = depth.clone();
11984 if inlined {
11985 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11986 inner_offset = next_offset;
11987 } else {
11988 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11989 inner_depth.increment()?;
11990 }
11991 let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
11992 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11993 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11994 {
11995 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11996 }
11997 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11998 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11999 }
12000 }
12001
12002 next_offset += envelope_size;
12003
12004 while next_offset < end_offset {
12006 _next_ordinal_to_read += 1;
12007 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12008 next_offset += envelope_size;
12009 }
12010
12011 Ok(())
12012 }
12013 }
12014
12015 impl ScanOptions {
12016 #[inline(always)]
12017 fn max_ordinal_present(&self) -> u64 {
12018 if let Some(_) = self.filters {
12019 return 1;
12020 }
12021 0
12022 }
12023 }
12024
12025 impl fidl::encoding::ValueTypeMarker for ScanOptions {
12026 type Borrowed<'a> = &'a Self;
12027 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12028 value
12029 }
12030 }
12031
12032 unsafe impl fidl::encoding::TypeMarker for ScanOptions {
12033 type Owned = Self;
12034
12035 #[inline(always)]
12036 fn inline_align(_context: fidl::encoding::Context) -> usize {
12037 8
12038 }
12039
12040 #[inline(always)]
12041 fn inline_size(_context: fidl::encoding::Context) -> usize {
12042 16
12043 }
12044 }
12045
12046 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanOptions, D>
12047 for &ScanOptions
12048 {
12049 unsafe fn encode(
12050 self,
12051 encoder: &mut fidl::encoding::Encoder<'_, D>,
12052 offset: usize,
12053 mut depth: fidl::encoding::Depth,
12054 ) -> fidl::Result<()> {
12055 encoder.debug_check_bounds::<ScanOptions>(offset);
12056 let max_ordinal: u64 = self.max_ordinal_present();
12058 encoder.write_num(max_ordinal, offset);
12059 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12060 if max_ordinal == 0 {
12062 return Ok(());
12063 }
12064 depth.increment()?;
12065 let envelope_size = 8;
12066 let bytes_len = max_ordinal as usize * envelope_size;
12067 #[allow(unused_variables)]
12068 let offset = encoder.out_of_line_offset(bytes_len);
12069 let mut _prev_end_offset: usize = 0;
12070 if 1 > max_ordinal {
12071 return Ok(());
12072 }
12073
12074 let cur_offset: usize = (1 - 1) * envelope_size;
12077
12078 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12080
12081 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Filter>, D>(
12086 self.filters.as_ref().map(<fidl::encoding::UnboundedVector<Filter> as fidl::encoding::ValueTypeMarker>::borrow),
12087 encoder, offset + cur_offset, depth
12088 )?;
12089
12090 _prev_end_offset = cur_offset + envelope_size;
12091
12092 Ok(())
12093 }
12094 }
12095
12096 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanOptions {
12097 #[inline(always)]
12098 fn new_empty() -> Self {
12099 Self::default()
12100 }
12101
12102 unsafe fn decode(
12103 &mut self,
12104 decoder: &mut fidl::encoding::Decoder<'_, D>,
12105 offset: usize,
12106 mut depth: fidl::encoding::Depth,
12107 ) -> fidl::Result<()> {
12108 decoder.debug_check_bounds::<Self>(offset);
12109 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12110 None => return Err(fidl::Error::NotNullable),
12111 Some(len) => len,
12112 };
12113 if len == 0 {
12115 return Ok(());
12116 };
12117 depth.increment()?;
12118 let envelope_size = 8;
12119 let bytes_len = len * envelope_size;
12120 let offset = decoder.out_of_line_offset(bytes_len)?;
12121 let mut _next_ordinal_to_read = 0;
12123 let mut next_offset = offset;
12124 let end_offset = offset + bytes_len;
12125 _next_ordinal_to_read += 1;
12126 if next_offset >= end_offset {
12127 return Ok(());
12128 }
12129
12130 while _next_ordinal_to_read < 1 {
12132 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12133 _next_ordinal_to_read += 1;
12134 next_offset += envelope_size;
12135 }
12136
12137 let next_out_of_line = decoder.next_out_of_line();
12138 let handles_before = decoder.remaining_handles();
12139 if let Some((inlined, num_bytes, num_handles)) =
12140 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12141 {
12142 let member_inline_size = <fidl::encoding::UnboundedVector<Filter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12143 if inlined != (member_inline_size <= 4) {
12144 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12145 }
12146 let inner_offset;
12147 let mut inner_depth = depth.clone();
12148 if inlined {
12149 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12150 inner_offset = next_offset;
12151 } else {
12152 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12153 inner_depth.increment()?;
12154 }
12155 let val_ref = self.filters.get_or_insert_with(|| {
12156 fidl::new_empty!(fidl::encoding::UnboundedVector<Filter>, D)
12157 });
12158 fidl::decode!(
12159 fidl::encoding::UnboundedVector<Filter>,
12160 D,
12161 val_ref,
12162 decoder,
12163 inner_offset,
12164 inner_depth
12165 )?;
12166 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12167 {
12168 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12169 }
12170 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12171 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12172 }
12173 }
12174
12175 next_offset += envelope_size;
12176
12177 while next_offset < end_offset {
12179 _next_ordinal_to_read += 1;
12180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12181 next_offset += envelope_size;
12182 }
12183
12184 Ok(())
12185 }
12186 }
12187
12188 impl fidl::encoding::ValueTypeMarker for AdvertisingProcedure {
12189 type Borrowed<'a> = &'a Self;
12190 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12191 value
12192 }
12193 }
12194
12195 unsafe impl fidl::encoding::TypeMarker for AdvertisingProcedure {
12196 type Owned = Self;
12197
12198 #[inline(always)]
12199 fn inline_align(_context: fidl::encoding::Context) -> usize {
12200 8
12201 }
12202
12203 #[inline(always)]
12204 fn inline_size(_context: fidl::encoding::Context) -> usize {
12205 16
12206 }
12207 }
12208
12209 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingProcedure, D>
12210 for &AdvertisingProcedure
12211 {
12212 #[inline]
12213 unsafe fn encode(
12214 self,
12215 encoder: &mut fidl::encoding::Encoder<'_, D>,
12216 offset: usize,
12217 _depth: fidl::encoding::Depth,
12218 ) -> fidl::Result<()> {
12219 encoder.debug_check_bounds::<AdvertisingProcedure>(offset);
12220 encoder.write_num::<u64>(self.ordinal(), offset);
12221 match self {
12222 AdvertisingProcedure::Legacy(ref val) => {
12223 fidl::encoding::encode_in_envelope::<Legacy, D>(
12224 <Legacy as fidl::encoding::ValueTypeMarker>::borrow(val),
12225 encoder,
12226 offset + 8,
12227 _depth,
12228 )
12229 }
12230 AdvertisingProcedure::Extended(ref val) => {
12231 fidl::encoding::encode_in_envelope::<Extended, D>(
12232 <Extended as fidl::encoding::ValueTypeMarker>::borrow(val),
12233 encoder,
12234 offset + 8,
12235 _depth,
12236 )
12237 }
12238 AdvertisingProcedure::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
12239 }
12240 }
12241 }
12242
12243 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingProcedure {
12244 #[inline(always)]
12245 fn new_empty() -> Self {
12246 Self::__SourceBreaking { unknown_ordinal: 0 }
12247 }
12248
12249 #[inline]
12250 unsafe fn decode(
12251 &mut self,
12252 decoder: &mut fidl::encoding::Decoder<'_, D>,
12253 offset: usize,
12254 mut depth: fidl::encoding::Depth,
12255 ) -> fidl::Result<()> {
12256 decoder.debug_check_bounds::<Self>(offset);
12257 #[allow(unused_variables)]
12258 let next_out_of_line = decoder.next_out_of_line();
12259 let handles_before = decoder.remaining_handles();
12260 let (ordinal, inlined, num_bytes, num_handles) =
12261 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12262
12263 let member_inline_size = match ordinal {
12264 1 => <Legacy as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12265 2 => <Extended as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12266 0 => return Err(fidl::Error::UnknownUnionTag),
12267 _ => num_bytes as usize,
12268 };
12269
12270 if inlined != (member_inline_size <= 4) {
12271 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12272 }
12273 let _inner_offset;
12274 if inlined {
12275 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12276 _inner_offset = offset + 8;
12277 } else {
12278 depth.increment()?;
12279 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12280 }
12281 match ordinal {
12282 1 => {
12283 #[allow(irrefutable_let_patterns)]
12284 if let AdvertisingProcedure::Legacy(_) = self {
12285 } else {
12287 *self = AdvertisingProcedure::Legacy(fidl::new_empty!(Legacy, D));
12289 }
12290 #[allow(irrefutable_let_patterns)]
12291 if let AdvertisingProcedure::Legacy(ref mut val) = self {
12292 fidl::decode!(Legacy, D, val, decoder, _inner_offset, depth)?;
12293 } else {
12294 unreachable!()
12295 }
12296 }
12297 2 => {
12298 #[allow(irrefutable_let_patterns)]
12299 if let AdvertisingProcedure::Extended(_) = self {
12300 } else {
12302 *self = AdvertisingProcedure::Extended(fidl::new_empty!(Extended, D));
12304 }
12305 #[allow(irrefutable_let_patterns)]
12306 if let AdvertisingProcedure::Extended(ref mut val) = self {
12307 fidl::decode!(Extended, D, val, decoder, _inner_offset, depth)?;
12308 } else {
12309 unreachable!()
12310 }
12311 }
12312 #[allow(deprecated)]
12313 ordinal => {
12314 for _ in 0..num_handles {
12315 decoder.drop_next_handle()?;
12316 }
12317 *self = AdvertisingProcedure::__SourceBreaking { unknown_ordinal: ordinal };
12318 }
12319 }
12320 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12322 }
12323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12325 }
12326 Ok(())
12327 }
12328 }
12329}