1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const WLAN_MAX_KEYLIST_SIZE: u32 = 4;
12
13pub const WLAN_VIE_MAX_LEN: u32 = 514;
16
17#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18pub enum EapolTxResult {
19 Success,
20 TransmissionFailure,
21 #[doc(hidden)]
22 __SourceBreaking {
23 unknown_ordinal: u8,
24 },
25}
26
27#[macro_export]
29macro_rules! EapolTxResultUnknown {
30 () => {
31 _
32 };
33}
34
35impl EapolTxResult {
36 #[inline]
37 pub fn from_primitive(prim: u8) -> Option<Self> {
38 match prim {
39 0 => Some(Self::Success),
40 1 => Some(Self::TransmissionFailure),
41 _ => None,
42 }
43 }
44
45 #[inline]
46 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
47 match prim {
48 0 => Self::Success,
49 1 => Self::TransmissionFailure,
50 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
51 }
52 }
53
54 #[inline]
55 pub fn unknown() -> Self {
56 Self::__SourceBreaking { unknown_ordinal: 0xff }
57 }
58
59 #[inline]
60 pub const fn into_primitive(self) -> u8 {
61 match self {
62 Self::Success => 0,
63 Self::TransmissionFailure => 1,
64 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
65 }
66 }
67
68 #[inline]
69 pub fn is_unknown(&self) -> bool {
70 match self {
71 Self::__SourceBreaking { unknown_ordinal: _ } => true,
72 _ => false,
73 }
74 }
75}
76
77#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
78pub enum StartResult {
79 Success,
80 BssAlreadyStartedOrJoined,
81 ResetRequiredBeforeStart,
82 NotSupported,
83 #[doc(hidden)]
84 __SourceBreaking {
85 unknown_ordinal: u8,
86 },
87}
88
89#[macro_export]
91macro_rules! StartResultUnknown {
92 () => {
93 _
94 };
95}
96
97impl StartResult {
98 #[inline]
99 pub fn from_primitive(prim: u8) -> Option<Self> {
100 match prim {
101 0 => Some(Self::Success),
102 1 => Some(Self::BssAlreadyStartedOrJoined),
103 2 => Some(Self::ResetRequiredBeforeStart),
104 3 => Some(Self::NotSupported),
105 _ => None,
106 }
107 }
108
109 #[inline]
110 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
111 match prim {
112 0 => Self::Success,
113 1 => Self::BssAlreadyStartedOrJoined,
114 2 => Self::ResetRequiredBeforeStart,
115 3 => Self::NotSupported,
116 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
117 }
118 }
119
120 #[inline]
121 pub fn unknown() -> Self {
122 Self::__SourceBreaking { unknown_ordinal: 0xff }
123 }
124
125 #[inline]
126 pub const fn into_primitive(self) -> u8 {
127 match self {
128 Self::Success => 0,
129 Self::BssAlreadyStartedOrJoined => 1,
130 Self::ResetRequiredBeforeStart => 2,
131 Self::NotSupported => 3,
132 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
133 }
134 }
135
136 #[inline]
137 pub fn is_unknown(&self) -> bool {
138 match self {
139 Self::__SourceBreaking { unknown_ordinal: _ } => true,
140 _ => false,
141 }
142 }
143}
144
145#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
146pub enum StopResult {
147 Success,
148 BssAlreadyStopped,
149 InternalError,
150 #[doc(hidden)]
151 __SourceBreaking {
152 unknown_ordinal: u8,
153 },
154}
155
156#[macro_export]
158macro_rules! StopResultUnknown {
159 () => {
160 _
161 };
162}
163
164impl StopResult {
165 #[inline]
166 pub fn from_primitive(prim: u8) -> Option<Self> {
167 match prim {
168 0 => Some(Self::Success),
169 1 => Some(Self::BssAlreadyStopped),
170 2 => Some(Self::InternalError),
171 _ => None,
172 }
173 }
174
175 #[inline]
176 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
177 match prim {
178 0 => Self::Success,
179 1 => Self::BssAlreadyStopped,
180 2 => Self::InternalError,
181 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
182 }
183 }
184
185 #[inline]
186 pub fn unknown() -> Self {
187 Self::__SourceBreaking { unknown_ordinal: 0xff }
188 }
189
190 #[inline]
191 pub const fn into_primitive(self) -> u8 {
192 match self {
193 Self::Success => 0,
194 Self::BssAlreadyStopped => 1,
195 Self::InternalError => 2,
196 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
197 }
198 }
199
200 #[inline]
201 pub fn is_unknown(&self) -> bool {
202 match self {
203 Self::__SourceBreaking { unknown_ordinal: _ } => true,
204 _ => false,
205 }
206 }
207}
208
209#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
210pub enum WlanAssocResult {
211 Success,
212 RefusedReasonUnspecified,
213 RefusedNotAuthenticated,
214 RefusedCapabilitiesMismatch,
215 RefusedExternalReason,
216 RefusedApOutOfMemory,
217 RefusedBasicRatesMismatch,
218 RejectedEmergencyServicesNotSupported,
219 RefusedTemporarily,
220 #[doc(hidden)]
221 __SourceBreaking {
222 unknown_ordinal: u8,
223 },
224}
225
226#[macro_export]
228macro_rules! WlanAssocResultUnknown {
229 () => {
230 _
231 };
232}
233
234impl WlanAssocResult {
235 #[inline]
236 pub fn from_primitive(prim: u8) -> Option<Self> {
237 match prim {
238 0 => Some(Self::Success),
239 1 => Some(Self::RefusedReasonUnspecified),
240 2 => Some(Self::RefusedNotAuthenticated),
241 3 => Some(Self::RefusedCapabilitiesMismatch),
242 4 => Some(Self::RefusedExternalReason),
243 5 => Some(Self::RefusedApOutOfMemory),
244 6 => Some(Self::RefusedBasicRatesMismatch),
245 7 => Some(Self::RejectedEmergencyServicesNotSupported),
246 8 => Some(Self::RefusedTemporarily),
247 _ => None,
248 }
249 }
250
251 #[inline]
252 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
253 match prim {
254 0 => Self::Success,
255 1 => Self::RefusedReasonUnspecified,
256 2 => Self::RefusedNotAuthenticated,
257 3 => Self::RefusedCapabilitiesMismatch,
258 4 => Self::RefusedExternalReason,
259 5 => Self::RefusedApOutOfMemory,
260 6 => Self::RefusedBasicRatesMismatch,
261 7 => Self::RejectedEmergencyServicesNotSupported,
262 8 => Self::RefusedTemporarily,
263 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
264 }
265 }
266
267 #[inline]
268 pub fn unknown() -> Self {
269 Self::__SourceBreaking { unknown_ordinal: 0xff }
270 }
271
272 #[inline]
273 pub const fn into_primitive(self) -> u8 {
274 match self {
275 Self::Success => 0,
276 Self::RefusedReasonUnspecified => 1,
277 Self::RefusedNotAuthenticated => 2,
278 Self::RefusedCapabilitiesMismatch => 3,
279 Self::RefusedExternalReason => 4,
280 Self::RefusedApOutOfMemory => 5,
281 Self::RefusedBasicRatesMismatch => 6,
282 Self::RejectedEmergencyServicesNotSupported => 7,
283 Self::RefusedTemporarily => 8,
284 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
285 }
286 }
287
288 #[inline]
289 pub fn is_unknown(&self) -> bool {
290 match self {
291 Self::__SourceBreaking { unknown_ordinal: _ } => true,
292 _ => false,
293 }
294 }
295}
296
297#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
298pub enum WlanAuthResult {
299 Success,
300 Refused,
301 AntiCloggingTokenRequired,
302 FiniteCyclicGroupNotSupported,
303 Rejected,
304 FailureTimeout,
305 #[doc(hidden)]
306 __SourceBreaking {
307 unknown_ordinal: u8,
308 },
309}
310
311#[macro_export]
313macro_rules! WlanAuthResultUnknown {
314 () => {
315 _
316 };
317}
318
319impl WlanAuthResult {
320 #[inline]
321 pub fn from_primitive(prim: u8) -> Option<Self> {
322 match prim {
323 0 => Some(Self::Success),
324 1 => Some(Self::Refused),
325 2 => Some(Self::AntiCloggingTokenRequired),
326 3 => Some(Self::FiniteCyclicGroupNotSupported),
327 4 => Some(Self::Rejected),
328 5 => Some(Self::FailureTimeout),
329 _ => None,
330 }
331 }
332
333 #[inline]
334 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
335 match prim {
336 0 => Self::Success,
337 1 => Self::Refused,
338 2 => Self::AntiCloggingTokenRequired,
339 3 => Self::FiniteCyclicGroupNotSupported,
340 4 => Self::Rejected,
341 5 => Self::FailureTimeout,
342 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
343 }
344 }
345
346 #[inline]
347 pub fn unknown() -> Self {
348 Self::__SourceBreaking { unknown_ordinal: 0xff }
349 }
350
351 #[inline]
352 pub const fn into_primitive(self) -> u8 {
353 match self {
354 Self::Success => 0,
355 Self::Refused => 1,
356 Self::AntiCloggingTokenRequired => 2,
357 Self::FiniteCyclicGroupNotSupported => 3,
358 Self::Rejected => 4,
359 Self::FailureTimeout => 5,
360 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
361 }
362 }
363
364 #[inline]
365 pub fn is_unknown(&self) -> bool {
366 match self {
367 Self::__SourceBreaking { unknown_ordinal: _ } => true,
368 _ => false,
369 }
370 }
371}
372
373#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
374pub enum WlanAuthType {
375 OpenSystem,
376 SharedKey,
377 FastBssTransition,
378 Sae,
379 #[doc(hidden)]
380 __SourceBreaking {
381 unknown_ordinal: u8,
382 },
383}
384
385#[macro_export]
387macro_rules! WlanAuthTypeUnknown {
388 () => {
389 _
390 };
391}
392
393impl WlanAuthType {
394 #[inline]
395 pub fn from_primitive(prim: u8) -> Option<Self> {
396 match prim {
397 1 => Some(Self::OpenSystem),
398 2 => Some(Self::SharedKey),
399 3 => Some(Self::FastBssTransition),
400 4 => Some(Self::Sae),
401 _ => None,
402 }
403 }
404
405 #[inline]
406 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
407 match prim {
408 1 => Self::OpenSystem,
409 2 => Self::SharedKey,
410 3 => Self::FastBssTransition,
411 4 => Self::Sae,
412 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
413 }
414 }
415
416 #[inline]
417 pub fn unknown() -> Self {
418 Self::__SourceBreaking { unknown_ordinal: 0xff }
419 }
420
421 #[inline]
422 pub const fn into_primitive(self) -> u8 {
423 match self {
424 Self::OpenSystem => 1,
425 Self::SharedKey => 2,
426 Self::FastBssTransition => 3,
427 Self::Sae => 4,
428 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
429 }
430 }
431
432 #[inline]
433 pub fn is_unknown(&self) -> bool {
434 match self {
435 Self::__SourceBreaking { unknown_ordinal: _ } => true,
436 _ => false,
437 }
438 }
439}
440
441#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
442pub enum WlanScanResult {
443 Success,
444 NotSupported,
445 InvalidArgs,
446 InternalError,
447 ShouldWait,
448 CanceledByDriverOrFirmware,
449 #[doc(hidden)]
450 __SourceBreaking {
451 unknown_ordinal: u8,
452 },
453}
454
455#[macro_export]
457macro_rules! WlanScanResultUnknown {
458 () => {
459 _
460 };
461}
462
463impl WlanScanResult {
464 #[inline]
465 pub fn from_primitive(prim: u8) -> Option<Self> {
466 match prim {
467 0 => Some(Self::Success),
468 1 => Some(Self::NotSupported),
469 2 => Some(Self::InvalidArgs),
470 3 => Some(Self::InternalError),
471 4 => Some(Self::ShouldWait),
472 5 => Some(Self::CanceledByDriverOrFirmware),
473 _ => None,
474 }
475 }
476
477 #[inline]
478 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
479 match prim {
480 0 => Self::Success,
481 1 => Self::NotSupported,
482 2 => Self::InvalidArgs,
483 3 => Self::InternalError,
484 4 => Self::ShouldWait,
485 5 => Self::CanceledByDriverOrFirmware,
486 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
487 }
488 }
489
490 #[inline]
491 pub fn unknown() -> Self {
492 Self::__SourceBreaking { unknown_ordinal: 0xff }
493 }
494
495 #[inline]
496 pub const fn into_primitive(self) -> u8 {
497 match self {
498 Self::Success => 0,
499 Self::NotSupported => 1,
500 Self::InvalidArgs => 2,
501 Self::InternalError => 3,
502 Self::ShouldWait => 4,
503 Self::CanceledByDriverOrFirmware => 5,
504 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
505 }
506 }
507
508 #[inline]
509 pub fn is_unknown(&self) -> bool {
510 match self {
511 Self::__SourceBreaking { unknown_ordinal: _ } => true,
512 _ => false,
513 }
514 }
515}
516
517#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
518pub enum WlanScanType {
519 Active,
520 Passive,
521 #[doc(hidden)]
522 __SourceBreaking {
523 unknown_ordinal: u8,
524 },
525}
526
527#[macro_export]
529macro_rules! WlanScanTypeUnknown {
530 () => {
531 _
532 };
533}
534
535impl WlanScanType {
536 #[inline]
537 pub fn from_primitive(prim: u8) -> Option<Self> {
538 match prim {
539 1 => Some(Self::Active),
540 2 => Some(Self::Passive),
541 _ => None,
542 }
543 }
544
545 #[inline]
546 pub fn from_primitive_allow_unknown(prim: u8) -> Self {
547 match prim {
548 1 => Self::Active,
549 2 => Self::Passive,
550 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
551 }
552 }
553
554 #[inline]
555 pub fn unknown() -> Self {
556 Self::__SourceBreaking { unknown_ordinal: 0xff }
557 }
558
559 #[inline]
560 pub const fn into_primitive(self) -> u8 {
561 match self {
562 Self::Active => 1,
563 Self::Passive => 2,
564 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
565 }
566 }
567
568 #[inline]
569 pub fn is_unknown(&self) -> bool {
570 match self {
571 Self::__SourceBreaking { unknown_ordinal: _ } => true,
572 _ => false,
573 }
574 }
575}
576
577#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
578#[repr(C)]
579pub struct WlanFullmacChannelSwitchInfo {
580 pub new_channel: u8,
581}
582
583impl fidl::Persistable for WlanFullmacChannelSwitchInfo {}
584
585#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
586#[repr(C)]
587pub struct WlanFullmacImplIfcOnChannelSwitchRequest {
588 pub ind: WlanFullmacChannelSwitchInfo,
589}
590
591impl fidl::Persistable for WlanFullmacImplIfcOnChannelSwitchRequest {}
592
593#[derive(Clone, Debug, PartialEq)]
594pub struct WlanFullmacImplIfcOnWmmStatusRespRequest {
595 pub status: i32,
596 pub wmm_params: fidl_fuchsia_wlan_common__common::WlanWmmParameters,
597}
598
599impl fidl::Persistable for WlanFullmacImplIfcOnWmmStatusRespRequest {}
600
601#[derive(Clone, Debug, PartialEq)]
602pub struct WlanFullmacImplIfcSaeFrameRxRequest {
603 pub frame: SaeFrame,
604}
605
606impl fidl::Persistable for WlanFullmacImplIfcSaeFrameRxRequest {}
607
608#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
609#[repr(C)]
610pub struct WlanFullmacImplIfcSignalReportRequest {
611 pub ind: WlanFullmacSignalReportIndication,
612}
613
614impl fidl::Persistable for WlanFullmacImplIfcSignalReportRequest {}
615
616#[derive(Clone, Debug, PartialEq)]
617pub struct WlanFullmacImplSaeFrameTxRequest {
618 pub frame: SaeFrame,
619}
620
621impl fidl::Persistable for WlanFullmacImplSaeFrameTxRequest {}
622
623#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
624pub struct WlanFullmacImplSetKeysResponse {
625 pub resp: WlanFullmacSetKeysResp,
626}
627
628impl fidl::Persistable for WlanFullmacImplSetKeysResponse {}
629
630#[derive(Clone, Debug, PartialEq)]
631pub struct WlanFullmacImplGetIfaceHistogramStatsResponse {
632 pub stats: fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
633}
634
635impl fidl::Persistable for WlanFullmacImplGetIfaceHistogramStatsResponse {}
636
637#[derive(Clone, Debug, PartialEq)]
638pub struct WlanFullmacImplGetIfaceStatsResponse {
639 pub stats: fidl_fuchsia_wlan_stats__common::IfaceStats,
640}
641
642impl fidl::Persistable for WlanFullmacImplGetIfaceStatsResponse {}
643
644#[derive(Clone, Debug, PartialEq)]
645pub struct WlanFullmacImplQuerySecuritySupportResponse {
646 pub resp: fidl_fuchsia_wlan_common__common::SecuritySupport,
647}
648
649impl fidl::Persistable for WlanFullmacImplQuerySecuritySupportResponse {}
650
651#[derive(Clone, Debug, PartialEq)]
652pub struct WlanFullmacImplQuerySpectrumManagementSupportResponse {
653 pub resp: fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
654}
655
656impl fidl::Persistable for WlanFullmacImplQuerySpectrumManagementSupportResponse {}
657
658#[derive(Clone, Debug, PartialEq)]
659pub struct WlanFullmacImplQueryTelemetrySupportResponse {
660 pub resp: fidl_fuchsia_wlan_stats__common::TelemetrySupport,
661}
662
663impl fidl::Persistable for WlanFullmacImplQueryTelemetrySupportResponse {}
664
665#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
666pub struct WlanFullmacRssiStats {
667 pub hist: Vec<u64>,
668}
669
670impl fidl::Persistable for WlanFullmacRssiStats {}
671
672#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
673pub struct WlanFullmacSetKeysResp {
674 pub statuslist: Vec<i32>,
675}
676
677impl fidl::Persistable for WlanFullmacSetKeysResp {}
678
679#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
680#[repr(C)]
681pub struct WlanFullmacSignalReportIndication {
682 pub rssi_dbm: i8,
683 pub snr_db: i8,
684}
685
686impl fidl::Persistable for WlanFullmacSignalReportIndication {}
687
688#[derive(Clone, Debug, Default, PartialEq)]
690pub struct BandCapability {
691 pub band: Option<fidl_fuchsia_wlan_ieee80211__common::WlanBand>,
695 pub basic_rates: Option<Vec<u8>>,
702 pub ht_caps: Option<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
707 pub vht_caps: Option<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
712 pub operating_channels: Option<Vec<u8>>,
724 #[doc(hidden)]
725 pub __source_breaking: fidl::marker::SourceBreaking,
726}
727
728impl fidl::Persistable for BandCapability {}
729
730#[derive(Clone, Debug, Default, PartialEq)]
733pub struct SaeFrame {
734 pub peer_sta_address: Option<[u8; 6]>,
736 pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
738 pub seq_num: Option<u16>,
740 pub sae_fields: Option<Vec<u8>>,
744 #[doc(hidden)]
745 pub __source_breaking: fidl::marker::SourceBreaking,
746}
747
748impl fidl::Persistable for SaeFrame {}
749
750#[derive(Clone, Debug, Default, PartialEq)]
751pub struct WlanFullmacImplAssocRespRequest {
752 pub peer_sta_address: Option<[u8; 6]>,
753 pub result_code: Option<WlanAssocResult>,
754 pub association_id: Option<u16>,
755 #[doc(hidden)]
756 pub __source_breaking: fidl::marker::SourceBreaking,
757}
758
759impl fidl::Persistable for WlanFullmacImplAssocRespRequest {}
760
761#[derive(Clone, Debug, Default, PartialEq)]
762pub struct WlanFullmacImplAuthRespRequest {
763 pub peer_sta_address: Option<[u8; 6]>,
764 pub result_code: Option<WlanAuthResult>,
765 #[doc(hidden)]
766 pub __source_breaking: fidl::marker::SourceBreaking,
767}
768
769impl fidl::Persistable for WlanFullmacImplAuthRespRequest {}
770
771#[derive(Clone, Debug, Default, PartialEq)]
772pub struct WlanFullmacImplConnectRequest {
773 pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
774 pub connect_failure_timeout: Option<u32>,
776 pub auth_type: Option<WlanAuthType>,
778 pub sae_password: Option<Vec<u8>>,
781 pub wep_key: Option<fidl_fuchsia_wlan_common__common::WlanKeyConfig>,
784 pub security_ie: Option<Vec<u8>>,
786 pub wep_key_desc: Option<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor>,
789 #[doc(hidden)]
790 pub __source_breaking: fidl::marker::SourceBreaking,
791}
792
793impl fidl::Persistable for WlanFullmacImplConnectRequest {}
794
795#[derive(Clone, Debug, Default, PartialEq)]
796pub struct WlanFullmacImplDeauthRequest {
797 pub peer_sta_address: Option<[u8; 6]>,
798 pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
799 #[doc(hidden)]
800 pub __source_breaking: fidl::marker::SourceBreaking,
801}
802
803impl fidl::Persistable for WlanFullmacImplDeauthRequest {}
804
805#[derive(Clone, Debug, Default, PartialEq)]
806pub struct WlanFullmacImplDisassocRequest {
807 pub peer_sta_address: Option<[u8; 6]>,
808 pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
809 #[doc(hidden)]
810 pub __source_breaking: fidl::marker::SourceBreaking,
811}
812
813impl fidl::Persistable for WlanFullmacImplDisassocRequest {}
814
815#[derive(Clone, Debug, Default, PartialEq)]
816pub struct WlanFullmacImplEapolTxRequest {
817 pub src_addr: Option<[u8; 6]>,
818 pub dst_addr: Option<[u8; 6]>,
819 pub data: Option<Vec<u8>>,
820 #[doc(hidden)]
821 pub __source_breaking: fidl::marker::SourceBreaking,
822}
823
824impl fidl::Persistable for WlanFullmacImplEapolTxRequest {}
825
826#[derive(Clone, Debug, Default, PartialEq)]
827pub struct WlanFullmacImplIfcAssocIndRequest {
828 pub peer_sta_address: Option<[u8; 6]>,
829 pub listen_interval: Option<u16>,
830 pub ssid: Option<Vec<u8>>,
831 pub rsne: Option<Vec<u8>>,
832 pub vendor_ie: Option<Vec<u8>>,
833 #[doc(hidden)]
834 pub __source_breaking: fidl::marker::SourceBreaking,
835}
836
837impl fidl::Persistable for WlanFullmacImplIfcAssocIndRequest {}
838
839#[derive(Clone, Debug, Default, PartialEq)]
840pub struct WlanFullmacImplIfcAuthIndRequest {
841 pub peer_sta_address: Option<[u8; 6]>,
842 pub auth_type: Option<WlanAuthType>,
843 #[doc(hidden)]
844 pub __source_breaking: fidl::marker::SourceBreaking,
845}
846
847impl fidl::Persistable for WlanFullmacImplIfcAuthIndRequest {}
848
849#[derive(Clone, Debug, Default, PartialEq)]
850pub struct WlanFullmacImplIfcConnectConfRequest {
851 pub peer_sta_address: Option<[u8; 6]>,
852 pub result_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
853 pub association_id: Option<u16>,
854 pub association_ies: Option<Vec<u8>>,
855 #[doc(hidden)]
856 pub __source_breaking: fidl::marker::SourceBreaking,
857}
858
859impl fidl::Persistable for WlanFullmacImplIfcConnectConfRequest {}
860
861#[derive(Clone, Debug, Default, PartialEq)]
862pub struct WlanFullmacImplIfcDeauthConfRequest {
863 pub peer_sta_address: Option<[u8; 6]>,
864 #[doc(hidden)]
865 pub __source_breaking: fidl::marker::SourceBreaking,
866}
867
868impl fidl::Persistable for WlanFullmacImplIfcDeauthConfRequest {}
869
870#[derive(Clone, Debug, Default, PartialEq)]
871pub struct WlanFullmacImplIfcDeauthIndRequest {
872 pub peer_sta_address: Option<[u8; 6]>,
874 pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
876 pub locally_initiated: Option<bool>,
879 #[doc(hidden)]
880 pub __source_breaking: fidl::marker::SourceBreaking,
881}
882
883impl fidl::Persistable for WlanFullmacImplIfcDeauthIndRequest {}
884
885#[derive(Clone, Debug, Default, PartialEq)]
886pub struct WlanFullmacImplIfcDisassocConfRequest {
887 pub status: Option<i32>,
895 #[doc(hidden)]
896 pub __source_breaking: fidl::marker::SourceBreaking,
897}
898
899impl fidl::Persistable for WlanFullmacImplIfcDisassocConfRequest {}
900
901#[derive(Clone, Debug, Default, PartialEq)]
902pub struct WlanFullmacImplIfcDisassocIndRequest {
903 pub peer_sta_address: Option<[u8; 6]>,
905 pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
907 pub locally_initiated: Option<bool>,
912 #[doc(hidden)]
913 pub __source_breaking: fidl::marker::SourceBreaking,
914}
915
916impl fidl::Persistable for WlanFullmacImplIfcDisassocIndRequest {}
917
918#[derive(Clone, Debug, Default, PartialEq)]
919pub struct WlanFullmacImplIfcEapolConfRequest {
920 pub result_code: Option<EapolTxResult>,
922 pub dst_addr: Option<[u8; 6]>,
927 #[doc(hidden)]
928 pub __source_breaking: fidl::marker::SourceBreaking,
929}
930
931impl fidl::Persistable for WlanFullmacImplIfcEapolConfRequest {}
932
933#[derive(Clone, Debug, Default, PartialEq)]
934pub struct WlanFullmacImplIfcEapolIndRequest {
935 pub src_addr: Option<[u8; 6]>,
937 pub dst_addr: Option<[u8; 6]>,
939 pub data: Option<Vec<u8>>,
941 #[doc(hidden)]
942 pub __source_breaking: fidl::marker::SourceBreaking,
943}
944
945impl fidl::Persistable for WlanFullmacImplIfcEapolIndRequest {}
946
947#[derive(Clone, Debug, Default, PartialEq)]
948pub struct WlanFullmacImplIfcOnPmkAvailableRequest {
949 pub pmk: Option<Vec<u8>>,
951 pub pmkid: Option<Vec<u8>>,
953 #[doc(hidden)]
954 pub __source_breaking: fidl::marker::SourceBreaking,
955}
956
957impl fidl::Persistable for WlanFullmacImplIfcOnPmkAvailableRequest {}
958
959#[derive(Clone, Debug, Default, PartialEq)]
960pub struct WlanFullmacImplIfcOnScanEndRequest {
961 pub txn_id: Option<u64>,
962 pub code: Option<WlanScanResult>,
963 #[doc(hidden)]
964 pub __source_breaking: fidl::marker::SourceBreaking,
965}
966
967impl fidl::Persistable for WlanFullmacImplIfcOnScanEndRequest {}
968
969#[derive(Clone, Debug, Default, PartialEq)]
970pub struct WlanFullmacImplIfcOnScanResultRequest {
971 pub txn_id: Option<u64>,
972 pub timestamp_nanos: Option<i64>,
973 pub bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
974 #[doc(hidden)]
975 pub __source_breaking: fidl::marker::SourceBreaking,
976}
977
978impl fidl::Persistable for WlanFullmacImplIfcOnScanResultRequest {}
979
980#[derive(Clone, Debug, Default, PartialEq)]
981pub struct WlanFullmacImplIfcRoamConfRequest {
982 pub selected_bssid: Option<[u8; 6]>,
984 pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
986 pub original_association_maintained: Option<bool>,
991 pub target_bss_authenticated: Option<bool>,
996 pub association_id: Option<u16>,
998 pub association_ies: Option<Vec<u8>>,
1000 #[doc(hidden)]
1001 pub __source_breaking: fidl::marker::SourceBreaking,
1002}
1003
1004impl fidl::Persistable for WlanFullmacImplIfcRoamConfRequest {}
1005
1006#[derive(Clone, Debug, Default, PartialEq)]
1007pub struct WlanFullmacImplIfcRoamResultIndRequest {
1008 pub selected_bssid: Option<[u8; 6]>,
1010 pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
1012 pub original_association_maintained: Option<bool>,
1017 pub target_bss_authenticated: Option<bool>,
1022 pub association_id: Option<u16>,
1024 pub association_ies: Option<Vec<u8>>,
1026 #[doc(hidden)]
1027 pub __source_breaking: fidl::marker::SourceBreaking,
1028}
1029
1030impl fidl::Persistable for WlanFullmacImplIfcRoamResultIndRequest {}
1031
1032#[derive(Clone, Debug, Default, PartialEq)]
1033pub struct WlanFullmacImplIfcRoamStartIndRequest {
1034 pub selected_bssid: Option<[u8; 6]>,
1036 pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
1040 pub original_association_maintained: Option<bool>,
1048 #[doc(hidden)]
1049 pub __source_breaking: fidl::marker::SourceBreaking,
1050}
1051
1052impl fidl::Persistable for WlanFullmacImplIfcRoamStartIndRequest {}
1053
1054#[derive(Clone, Debug, Default, PartialEq)]
1055pub struct WlanFullmacImplIfcSaeHandshakeIndRequest {
1056 pub peer_sta_address: Option<[u8; 6]>,
1057 #[doc(hidden)]
1058 pub __source_breaking: fidl::marker::SourceBreaking,
1059}
1060
1061impl fidl::Persistable for WlanFullmacImplIfcSaeHandshakeIndRequest {}
1062
1063#[derive(Clone, Debug, Default, PartialEq)]
1064pub struct WlanFullmacImplIfcStartConfRequest {
1065 pub result_code: Option<StartResult>,
1067 #[doc(hidden)]
1068 pub __source_breaking: fidl::marker::SourceBreaking,
1069}
1070
1071impl fidl::Persistable for WlanFullmacImplIfcStartConfRequest {}
1072
1073#[derive(Clone, Debug, Default, PartialEq)]
1074pub struct WlanFullmacImplIfcStopConfRequest {
1075 pub result_code: Option<StopResult>,
1077 #[doc(hidden)]
1078 pub __source_breaking: fidl::marker::SourceBreaking,
1079}
1080
1081impl fidl::Persistable for WlanFullmacImplIfcStopConfRequest {}
1082
1083#[derive(Clone, Debug, Default, PartialEq)]
1084pub struct WlanFullmacImplOnLinkStateChangedRequest {
1085 pub online: Option<bool>,
1086 #[doc(hidden)]
1087 pub __source_breaking: fidl::marker::SourceBreaking,
1088}
1089
1090impl fidl::Persistable for WlanFullmacImplOnLinkStateChangedRequest {}
1091
1092#[derive(Clone, Debug, Default, PartialEq)]
1093pub struct WlanFullmacImplReconnectRequest {
1094 pub peer_sta_address: Option<[u8; 6]>,
1095 #[doc(hidden)]
1096 pub __source_breaking: fidl::marker::SourceBreaking,
1097}
1098
1099impl fidl::Persistable for WlanFullmacImplReconnectRequest {}
1100
1101#[derive(Clone, Debug, Default, PartialEq)]
1102pub struct WlanFullmacImplRoamRequest {
1103 pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
1107 #[doc(hidden)]
1108 pub __source_breaking: fidl::marker::SourceBreaking,
1109}
1110
1111impl fidl::Persistable for WlanFullmacImplRoamRequest {}
1112
1113#[derive(Clone, Debug, Default, PartialEq)]
1114pub struct WlanFullmacImplSaeHandshakeRespRequest {
1115 pub peer_sta_address: Option<[u8; 6]>,
1117 pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
1119 #[doc(hidden)]
1120 pub __source_breaking: fidl::marker::SourceBreaking,
1121}
1122
1123impl fidl::Persistable for WlanFullmacImplSaeHandshakeRespRequest {}
1124
1125#[derive(Clone, Debug, Default, PartialEq)]
1126pub struct WlanFullmacImplSetKeysRequest {
1127 pub keylist: Option<Vec<fidl_fuchsia_wlan_common__common::WlanKeyConfig>>,
1128 pub key_descriptors: Option<Vec<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor>>,
1129 #[doc(hidden)]
1130 pub __source_breaking: fidl::marker::SourceBreaking,
1131}
1132
1133impl fidl::Persistable for WlanFullmacImplSetKeysRequest {}
1134
1135#[derive(Clone, Debug, Default, PartialEq)]
1136pub struct WlanFullmacImplStartBssRequest {
1137 pub ssid: Option<Vec<u8>>,
1138 pub bss_type: Option<fidl_fuchsia_wlan_common__common::BssType>,
1139 pub beacon_period: Option<u32>,
1140 pub dtim_period: Option<u32>,
1141 pub channel: Option<u8>,
1142 pub rsne: Option<Vec<u8>>,
1143 pub vendor_ie: Option<Vec<u8>>,
1144 #[doc(hidden)]
1145 pub __source_breaking: fidl::marker::SourceBreaking,
1146}
1147
1148impl fidl::Persistable for WlanFullmacImplStartBssRequest {}
1149
1150#[derive(Clone, Debug, Default, PartialEq)]
1151pub struct WlanFullmacImplStartScanRequest {
1152 pub txn_id: Option<u64>,
1154 pub scan_type: Option<WlanScanType>,
1155 pub channels: Option<Vec<u8>>,
1163 pub ssids: Option<Vec<Vec<u8>>>,
1172 pub min_channel_time: Option<u32>,
1174 pub max_channel_time: Option<u32>,
1176 #[doc(hidden)]
1177 pub __source_breaking: fidl::marker::SourceBreaking,
1178}
1179
1180impl fidl::Persistable for WlanFullmacImplStartScanRequest {}
1181
1182#[derive(Clone, Debug, Default, PartialEq)]
1183pub struct WlanFullmacImplStopBssRequest {
1184 pub ssid: Option<Vec<u8>>,
1185 #[doc(hidden)]
1186 pub __source_breaking: fidl::marker::SourceBreaking,
1187}
1188
1189impl fidl::Persistable for WlanFullmacImplStopBssRequest {}
1190
1191#[derive(Clone, Debug, Default, PartialEq)]
1192pub struct WlanFullmacImplQueryResponse {
1193 pub sta_addr: Option<[u8; 6]>,
1195 pub role: Option<fidl_fuchsia_wlan_common__common::WlanMacRole>,
1197 pub band_caps: Option<Vec<BandCapability>>,
1199 #[doc(hidden)]
1200 pub __source_breaking: fidl::marker::SourceBreaking,
1201}
1202
1203impl fidl::Persistable for WlanFullmacImplQueryResponse {}
1204
1205mod internal {
1206 use super::*;
1207 unsafe impl fidl::encoding::TypeMarker for EapolTxResult {
1208 type Owned = Self;
1209
1210 #[inline(always)]
1211 fn inline_align(_context: fidl::encoding::Context) -> usize {
1212 std::mem::align_of::<u8>()
1213 }
1214
1215 #[inline(always)]
1216 fn inline_size(_context: fidl::encoding::Context) -> usize {
1217 std::mem::size_of::<u8>()
1218 }
1219
1220 #[inline(always)]
1221 fn encode_is_copy() -> bool {
1222 false
1223 }
1224
1225 #[inline(always)]
1226 fn decode_is_copy() -> bool {
1227 false
1228 }
1229 }
1230
1231 impl fidl::encoding::ValueTypeMarker for EapolTxResult {
1232 type Borrowed<'a> = Self;
1233 #[inline(always)]
1234 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1235 *value
1236 }
1237 }
1238
1239 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EapolTxResult {
1240 #[inline]
1241 unsafe fn encode(
1242 self,
1243 encoder: &mut fidl::encoding::Encoder<'_, D>,
1244 offset: usize,
1245 _depth: fidl::encoding::Depth,
1246 ) -> fidl::Result<()> {
1247 encoder.debug_check_bounds::<Self>(offset);
1248 encoder.write_num(self.into_primitive(), offset);
1249 Ok(())
1250 }
1251 }
1252
1253 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolTxResult {
1254 #[inline(always)]
1255 fn new_empty() -> Self {
1256 Self::unknown()
1257 }
1258
1259 #[inline]
1260 unsafe fn decode(
1261 &mut self,
1262 decoder: &mut fidl::encoding::Decoder<'_, D>,
1263 offset: usize,
1264 _depth: fidl::encoding::Depth,
1265 ) -> fidl::Result<()> {
1266 decoder.debug_check_bounds::<Self>(offset);
1267 let prim = decoder.read_num::<u8>(offset);
1268
1269 *self = Self::from_primitive_allow_unknown(prim);
1270 Ok(())
1271 }
1272 }
1273 unsafe impl fidl::encoding::TypeMarker for StartResult {
1274 type Owned = Self;
1275
1276 #[inline(always)]
1277 fn inline_align(_context: fidl::encoding::Context) -> usize {
1278 std::mem::align_of::<u8>()
1279 }
1280
1281 #[inline(always)]
1282 fn inline_size(_context: fidl::encoding::Context) -> usize {
1283 std::mem::size_of::<u8>()
1284 }
1285
1286 #[inline(always)]
1287 fn encode_is_copy() -> bool {
1288 false
1289 }
1290
1291 #[inline(always)]
1292 fn decode_is_copy() -> bool {
1293 false
1294 }
1295 }
1296
1297 impl fidl::encoding::ValueTypeMarker for StartResult {
1298 type Borrowed<'a> = Self;
1299 #[inline(always)]
1300 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1301 *value
1302 }
1303 }
1304
1305 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartResult {
1306 #[inline]
1307 unsafe fn encode(
1308 self,
1309 encoder: &mut fidl::encoding::Encoder<'_, D>,
1310 offset: usize,
1311 _depth: fidl::encoding::Depth,
1312 ) -> fidl::Result<()> {
1313 encoder.debug_check_bounds::<Self>(offset);
1314 encoder.write_num(self.into_primitive(), offset);
1315 Ok(())
1316 }
1317 }
1318
1319 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartResult {
1320 #[inline(always)]
1321 fn new_empty() -> Self {
1322 Self::unknown()
1323 }
1324
1325 #[inline]
1326 unsafe fn decode(
1327 &mut self,
1328 decoder: &mut fidl::encoding::Decoder<'_, D>,
1329 offset: usize,
1330 _depth: fidl::encoding::Depth,
1331 ) -> fidl::Result<()> {
1332 decoder.debug_check_bounds::<Self>(offset);
1333 let prim = decoder.read_num::<u8>(offset);
1334
1335 *self = Self::from_primitive_allow_unknown(prim);
1336 Ok(())
1337 }
1338 }
1339 unsafe impl fidl::encoding::TypeMarker for StopResult {
1340 type Owned = Self;
1341
1342 #[inline(always)]
1343 fn inline_align(_context: fidl::encoding::Context) -> usize {
1344 std::mem::align_of::<u8>()
1345 }
1346
1347 #[inline(always)]
1348 fn inline_size(_context: fidl::encoding::Context) -> usize {
1349 std::mem::size_of::<u8>()
1350 }
1351
1352 #[inline(always)]
1353 fn encode_is_copy() -> bool {
1354 false
1355 }
1356
1357 #[inline(always)]
1358 fn decode_is_copy() -> bool {
1359 false
1360 }
1361 }
1362
1363 impl fidl::encoding::ValueTypeMarker for StopResult {
1364 type Borrowed<'a> = Self;
1365 #[inline(always)]
1366 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1367 *value
1368 }
1369 }
1370
1371 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopResult {
1372 #[inline]
1373 unsafe fn encode(
1374 self,
1375 encoder: &mut fidl::encoding::Encoder<'_, D>,
1376 offset: usize,
1377 _depth: fidl::encoding::Depth,
1378 ) -> fidl::Result<()> {
1379 encoder.debug_check_bounds::<Self>(offset);
1380 encoder.write_num(self.into_primitive(), offset);
1381 Ok(())
1382 }
1383 }
1384
1385 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
1386 #[inline(always)]
1387 fn new_empty() -> Self {
1388 Self::unknown()
1389 }
1390
1391 #[inline]
1392 unsafe fn decode(
1393 &mut self,
1394 decoder: &mut fidl::encoding::Decoder<'_, D>,
1395 offset: usize,
1396 _depth: fidl::encoding::Depth,
1397 ) -> fidl::Result<()> {
1398 decoder.debug_check_bounds::<Self>(offset);
1399 let prim = decoder.read_num::<u8>(offset);
1400
1401 *self = Self::from_primitive_allow_unknown(prim);
1402 Ok(())
1403 }
1404 }
1405 unsafe impl fidl::encoding::TypeMarker for WlanAssocResult {
1406 type Owned = Self;
1407
1408 #[inline(always)]
1409 fn inline_align(_context: fidl::encoding::Context) -> usize {
1410 std::mem::align_of::<u8>()
1411 }
1412
1413 #[inline(always)]
1414 fn inline_size(_context: fidl::encoding::Context) -> usize {
1415 std::mem::size_of::<u8>()
1416 }
1417
1418 #[inline(always)]
1419 fn encode_is_copy() -> bool {
1420 false
1421 }
1422
1423 #[inline(always)]
1424 fn decode_is_copy() -> bool {
1425 false
1426 }
1427 }
1428
1429 impl fidl::encoding::ValueTypeMarker for WlanAssocResult {
1430 type Borrowed<'a> = Self;
1431 #[inline(always)]
1432 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1433 *value
1434 }
1435 }
1436
1437 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1438 for WlanAssocResult
1439 {
1440 #[inline]
1441 unsafe fn encode(
1442 self,
1443 encoder: &mut fidl::encoding::Encoder<'_, D>,
1444 offset: usize,
1445 _depth: fidl::encoding::Depth,
1446 ) -> fidl::Result<()> {
1447 encoder.debug_check_bounds::<Self>(offset);
1448 encoder.write_num(self.into_primitive(), offset);
1449 Ok(())
1450 }
1451 }
1452
1453 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAssocResult {
1454 #[inline(always)]
1455 fn new_empty() -> Self {
1456 Self::unknown()
1457 }
1458
1459 #[inline]
1460 unsafe fn decode(
1461 &mut self,
1462 decoder: &mut fidl::encoding::Decoder<'_, D>,
1463 offset: usize,
1464 _depth: fidl::encoding::Depth,
1465 ) -> fidl::Result<()> {
1466 decoder.debug_check_bounds::<Self>(offset);
1467 let prim = decoder.read_num::<u8>(offset);
1468
1469 *self = Self::from_primitive_allow_unknown(prim);
1470 Ok(())
1471 }
1472 }
1473 unsafe impl fidl::encoding::TypeMarker for WlanAuthResult {
1474 type Owned = Self;
1475
1476 #[inline(always)]
1477 fn inline_align(_context: fidl::encoding::Context) -> usize {
1478 std::mem::align_of::<u8>()
1479 }
1480
1481 #[inline(always)]
1482 fn inline_size(_context: fidl::encoding::Context) -> usize {
1483 std::mem::size_of::<u8>()
1484 }
1485
1486 #[inline(always)]
1487 fn encode_is_copy() -> bool {
1488 false
1489 }
1490
1491 #[inline(always)]
1492 fn decode_is_copy() -> bool {
1493 false
1494 }
1495 }
1496
1497 impl fidl::encoding::ValueTypeMarker for WlanAuthResult {
1498 type Borrowed<'a> = Self;
1499 #[inline(always)]
1500 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1501 *value
1502 }
1503 }
1504
1505 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthResult {
1506 #[inline]
1507 unsafe fn encode(
1508 self,
1509 encoder: &mut fidl::encoding::Encoder<'_, D>,
1510 offset: usize,
1511 _depth: fidl::encoding::Depth,
1512 ) -> fidl::Result<()> {
1513 encoder.debug_check_bounds::<Self>(offset);
1514 encoder.write_num(self.into_primitive(), offset);
1515 Ok(())
1516 }
1517 }
1518
1519 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthResult {
1520 #[inline(always)]
1521 fn new_empty() -> Self {
1522 Self::unknown()
1523 }
1524
1525 #[inline]
1526 unsafe fn decode(
1527 &mut self,
1528 decoder: &mut fidl::encoding::Decoder<'_, D>,
1529 offset: usize,
1530 _depth: fidl::encoding::Depth,
1531 ) -> fidl::Result<()> {
1532 decoder.debug_check_bounds::<Self>(offset);
1533 let prim = decoder.read_num::<u8>(offset);
1534
1535 *self = Self::from_primitive_allow_unknown(prim);
1536 Ok(())
1537 }
1538 }
1539 unsafe impl fidl::encoding::TypeMarker for WlanAuthType {
1540 type Owned = Self;
1541
1542 #[inline(always)]
1543 fn inline_align(_context: fidl::encoding::Context) -> usize {
1544 std::mem::align_of::<u8>()
1545 }
1546
1547 #[inline(always)]
1548 fn inline_size(_context: fidl::encoding::Context) -> usize {
1549 std::mem::size_of::<u8>()
1550 }
1551
1552 #[inline(always)]
1553 fn encode_is_copy() -> bool {
1554 false
1555 }
1556
1557 #[inline(always)]
1558 fn decode_is_copy() -> bool {
1559 false
1560 }
1561 }
1562
1563 impl fidl::encoding::ValueTypeMarker for WlanAuthType {
1564 type Borrowed<'a> = Self;
1565 #[inline(always)]
1566 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1567 *value
1568 }
1569 }
1570
1571 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthType {
1572 #[inline]
1573 unsafe fn encode(
1574 self,
1575 encoder: &mut fidl::encoding::Encoder<'_, D>,
1576 offset: usize,
1577 _depth: fidl::encoding::Depth,
1578 ) -> fidl::Result<()> {
1579 encoder.debug_check_bounds::<Self>(offset);
1580 encoder.write_num(self.into_primitive(), offset);
1581 Ok(())
1582 }
1583 }
1584
1585 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthType {
1586 #[inline(always)]
1587 fn new_empty() -> Self {
1588 Self::unknown()
1589 }
1590
1591 #[inline]
1592 unsafe fn decode(
1593 &mut self,
1594 decoder: &mut fidl::encoding::Decoder<'_, D>,
1595 offset: usize,
1596 _depth: fidl::encoding::Depth,
1597 ) -> fidl::Result<()> {
1598 decoder.debug_check_bounds::<Self>(offset);
1599 let prim = decoder.read_num::<u8>(offset);
1600
1601 *self = Self::from_primitive_allow_unknown(prim);
1602 Ok(())
1603 }
1604 }
1605 unsafe impl fidl::encoding::TypeMarker for WlanScanResult {
1606 type Owned = Self;
1607
1608 #[inline(always)]
1609 fn inline_align(_context: fidl::encoding::Context) -> usize {
1610 std::mem::align_of::<u8>()
1611 }
1612
1613 #[inline(always)]
1614 fn inline_size(_context: fidl::encoding::Context) -> usize {
1615 std::mem::size_of::<u8>()
1616 }
1617
1618 #[inline(always)]
1619 fn encode_is_copy() -> bool {
1620 false
1621 }
1622
1623 #[inline(always)]
1624 fn decode_is_copy() -> bool {
1625 false
1626 }
1627 }
1628
1629 impl fidl::encoding::ValueTypeMarker for WlanScanResult {
1630 type Borrowed<'a> = Self;
1631 #[inline(always)]
1632 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1633 *value
1634 }
1635 }
1636
1637 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanResult {
1638 #[inline]
1639 unsafe fn encode(
1640 self,
1641 encoder: &mut fidl::encoding::Encoder<'_, D>,
1642 offset: usize,
1643 _depth: fidl::encoding::Depth,
1644 ) -> fidl::Result<()> {
1645 encoder.debug_check_bounds::<Self>(offset);
1646 encoder.write_num(self.into_primitive(), offset);
1647 Ok(())
1648 }
1649 }
1650
1651 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanResult {
1652 #[inline(always)]
1653 fn new_empty() -> Self {
1654 Self::unknown()
1655 }
1656
1657 #[inline]
1658 unsafe fn decode(
1659 &mut self,
1660 decoder: &mut fidl::encoding::Decoder<'_, D>,
1661 offset: usize,
1662 _depth: fidl::encoding::Depth,
1663 ) -> fidl::Result<()> {
1664 decoder.debug_check_bounds::<Self>(offset);
1665 let prim = decoder.read_num::<u8>(offset);
1666
1667 *self = Self::from_primitive_allow_unknown(prim);
1668 Ok(())
1669 }
1670 }
1671 unsafe impl fidl::encoding::TypeMarker for WlanScanType {
1672 type Owned = Self;
1673
1674 #[inline(always)]
1675 fn inline_align(_context: fidl::encoding::Context) -> usize {
1676 std::mem::align_of::<u8>()
1677 }
1678
1679 #[inline(always)]
1680 fn inline_size(_context: fidl::encoding::Context) -> usize {
1681 std::mem::size_of::<u8>()
1682 }
1683
1684 #[inline(always)]
1685 fn encode_is_copy() -> bool {
1686 false
1687 }
1688
1689 #[inline(always)]
1690 fn decode_is_copy() -> bool {
1691 false
1692 }
1693 }
1694
1695 impl fidl::encoding::ValueTypeMarker for WlanScanType {
1696 type Borrowed<'a> = Self;
1697 #[inline(always)]
1698 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1699 *value
1700 }
1701 }
1702
1703 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanType {
1704 #[inline]
1705 unsafe fn encode(
1706 self,
1707 encoder: &mut fidl::encoding::Encoder<'_, D>,
1708 offset: usize,
1709 _depth: fidl::encoding::Depth,
1710 ) -> fidl::Result<()> {
1711 encoder.debug_check_bounds::<Self>(offset);
1712 encoder.write_num(self.into_primitive(), offset);
1713 Ok(())
1714 }
1715 }
1716
1717 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanType {
1718 #[inline(always)]
1719 fn new_empty() -> Self {
1720 Self::unknown()
1721 }
1722
1723 #[inline]
1724 unsafe fn decode(
1725 &mut self,
1726 decoder: &mut fidl::encoding::Decoder<'_, D>,
1727 offset: usize,
1728 _depth: fidl::encoding::Depth,
1729 ) -> fidl::Result<()> {
1730 decoder.debug_check_bounds::<Self>(offset);
1731 let prim = decoder.read_num::<u8>(offset);
1732
1733 *self = Self::from_primitive_allow_unknown(prim);
1734 Ok(())
1735 }
1736 }
1737
1738 impl fidl::encoding::ValueTypeMarker for WlanFullmacChannelSwitchInfo {
1739 type Borrowed<'a> = &'a Self;
1740 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1741 value
1742 }
1743 }
1744
1745 unsafe impl fidl::encoding::TypeMarker for WlanFullmacChannelSwitchInfo {
1746 type Owned = Self;
1747
1748 #[inline(always)]
1749 fn inline_align(_context: fidl::encoding::Context) -> usize {
1750 1
1751 }
1752
1753 #[inline(always)]
1754 fn inline_size(_context: fidl::encoding::Context) -> usize {
1755 1
1756 }
1757 #[inline(always)]
1758 fn encode_is_copy() -> bool {
1759 true
1760 }
1761
1762 #[inline(always)]
1763 fn decode_is_copy() -> bool {
1764 true
1765 }
1766 }
1767
1768 unsafe impl<D: fidl::encoding::ResourceDialect>
1769 fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for &WlanFullmacChannelSwitchInfo
1770 {
1771 #[inline]
1772 unsafe fn encode(
1773 self,
1774 encoder: &mut fidl::encoding::Encoder<'_, D>,
1775 offset: usize,
1776 _depth: fidl::encoding::Depth,
1777 ) -> fidl::Result<()> {
1778 encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1779 unsafe {
1780 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1782 (buf_ptr as *mut WlanFullmacChannelSwitchInfo)
1783 .write_unaligned((self as *const WlanFullmacChannelSwitchInfo).read());
1784 }
1787 Ok(())
1788 }
1789 }
1790 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1791 fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for (T0,)
1792 {
1793 #[inline]
1794 unsafe fn encode(
1795 self,
1796 encoder: &mut fidl::encoding::Encoder<'_, D>,
1797 offset: usize,
1798 depth: fidl::encoding::Depth,
1799 ) -> fidl::Result<()> {
1800 encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1801 self.0.encode(encoder, offset + 0, depth)?;
1805 Ok(())
1806 }
1807 }
1808
1809 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1810 for WlanFullmacChannelSwitchInfo
1811 {
1812 #[inline(always)]
1813 fn new_empty() -> Self {
1814 Self { new_channel: fidl::new_empty!(u8, D) }
1815 }
1816
1817 #[inline]
1818 unsafe fn decode(
1819 &mut self,
1820 decoder: &mut fidl::encoding::Decoder<'_, D>,
1821 offset: usize,
1822 _depth: fidl::encoding::Depth,
1823 ) -> fidl::Result<()> {
1824 decoder.debug_check_bounds::<Self>(offset);
1825 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1826 unsafe {
1829 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1830 }
1831 Ok(())
1832 }
1833 }
1834
1835 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1836 type Borrowed<'a> = &'a Self;
1837 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1838 value
1839 }
1840 }
1841
1842 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1843 type Owned = Self;
1844
1845 #[inline(always)]
1846 fn inline_align(_context: fidl::encoding::Context) -> usize {
1847 1
1848 }
1849
1850 #[inline(always)]
1851 fn inline_size(_context: fidl::encoding::Context) -> usize {
1852 1
1853 }
1854 #[inline(always)]
1855 fn encode_is_copy() -> bool {
1856 true
1857 }
1858
1859 #[inline(always)]
1860 fn decode_is_copy() -> bool {
1861 true
1862 }
1863 }
1864
1865 unsafe impl<D: fidl::encoding::ResourceDialect>
1866 fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D>
1867 for &WlanFullmacImplIfcOnChannelSwitchRequest
1868 {
1869 #[inline]
1870 unsafe fn encode(
1871 self,
1872 encoder: &mut fidl::encoding::Encoder<'_, D>,
1873 offset: usize,
1874 _depth: fidl::encoding::Depth,
1875 ) -> fidl::Result<()> {
1876 encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1877 unsafe {
1878 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1880 (buf_ptr as *mut WlanFullmacImplIfcOnChannelSwitchRequest).write_unaligned(
1881 (self as *const WlanFullmacImplIfcOnChannelSwitchRequest).read(),
1882 );
1883 }
1886 Ok(())
1887 }
1888 }
1889 unsafe impl<
1890 D: fidl::encoding::ResourceDialect,
1891 T0: fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D>,
1892 > fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D> for (T0,)
1893 {
1894 #[inline]
1895 unsafe fn encode(
1896 self,
1897 encoder: &mut fidl::encoding::Encoder<'_, D>,
1898 offset: usize,
1899 depth: fidl::encoding::Depth,
1900 ) -> fidl::Result<()> {
1901 encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1902 self.0.encode(encoder, offset + 0, depth)?;
1906 Ok(())
1907 }
1908 }
1909
1910 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1911 for WlanFullmacImplIfcOnChannelSwitchRequest
1912 {
1913 #[inline(always)]
1914 fn new_empty() -> Self {
1915 Self { ind: fidl::new_empty!(WlanFullmacChannelSwitchInfo, D) }
1916 }
1917
1918 #[inline]
1919 unsafe fn decode(
1920 &mut self,
1921 decoder: &mut fidl::encoding::Decoder<'_, D>,
1922 offset: usize,
1923 _depth: fidl::encoding::Depth,
1924 ) -> fidl::Result<()> {
1925 decoder.debug_check_bounds::<Self>(offset);
1926 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1927 unsafe {
1930 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1931 }
1932 Ok(())
1933 }
1934 }
1935
1936 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1937 type Borrowed<'a> = &'a Self;
1938 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1939 value
1940 }
1941 }
1942
1943 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1944 type Owned = Self;
1945
1946 #[inline(always)]
1947 fn inline_align(_context: fidl::encoding::Context) -> usize {
1948 4
1949 }
1950
1951 #[inline(always)]
1952 fn inline_size(_context: fidl::encoding::Context) -> usize {
1953 40
1954 }
1955 }
1956
1957 unsafe impl<D: fidl::encoding::ResourceDialect>
1958 fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D>
1959 for &WlanFullmacImplIfcOnWmmStatusRespRequest
1960 {
1961 #[inline]
1962 unsafe fn encode(
1963 self,
1964 encoder: &mut fidl::encoding::Encoder<'_, D>,
1965 offset: usize,
1966 _depth: fidl::encoding::Depth,
1967 ) -> fidl::Result<()> {
1968 encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
1969 fidl::encoding::Encode::<WlanFullmacImplIfcOnWmmStatusRespRequest, D>::encode(
1971 (
1972 <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1973 <fidl_fuchsia_wlan_common__common::WlanWmmParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_params),
1974 ),
1975 encoder, offset, _depth
1976 )
1977 }
1978 }
1979 unsafe impl<
1980 D: fidl::encoding::ResourceDialect,
1981 T0: fidl::encoding::Encode<i32, D>,
1982 T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanWmmParameters, D>,
1983 > fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D> for (T0, T1)
1984 {
1985 #[inline]
1986 unsafe fn encode(
1987 self,
1988 encoder: &mut fidl::encoding::Encoder<'_, D>,
1989 offset: usize,
1990 depth: fidl::encoding::Depth,
1991 ) -> fidl::Result<()> {
1992 encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
1993 unsafe {
1996 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
1997 (ptr as *mut u32).write_unaligned(0);
1998 }
1999 self.0.encode(encoder, offset + 0, depth)?;
2001 self.1.encode(encoder, offset + 4, depth)?;
2002 Ok(())
2003 }
2004 }
2005
2006 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2007 for WlanFullmacImplIfcOnWmmStatusRespRequest
2008 {
2009 #[inline(always)]
2010 fn new_empty() -> Self {
2011 Self {
2012 status: fidl::new_empty!(i32, D),
2013 wmm_params: fidl::new_empty!(
2014 fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2015 D
2016 ),
2017 }
2018 }
2019
2020 #[inline]
2021 unsafe fn decode(
2022 &mut self,
2023 decoder: &mut fidl::encoding::Decoder<'_, D>,
2024 offset: usize,
2025 _depth: fidl::encoding::Depth,
2026 ) -> fidl::Result<()> {
2027 decoder.debug_check_bounds::<Self>(offset);
2028 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
2030 let padval = unsafe { (ptr as *const u32).read_unaligned() };
2031 let mask = 0xffff0000u32;
2032 let maskedval = padval & mask;
2033 if maskedval != 0 {
2034 return Err(fidl::Error::NonZeroPadding {
2035 padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
2036 });
2037 }
2038 fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
2039 fidl::decode!(
2040 fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2041 D,
2042 &mut self.wmm_params,
2043 decoder,
2044 offset + 4,
2045 _depth
2046 )?;
2047 Ok(())
2048 }
2049 }
2050
2051 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2052 type Borrowed<'a> = &'a Self;
2053 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2054 value
2055 }
2056 }
2057
2058 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2059 type Owned = Self;
2060
2061 #[inline(always)]
2062 fn inline_align(_context: fidl::encoding::Context) -> usize {
2063 8
2064 }
2065
2066 #[inline(always)]
2067 fn inline_size(_context: fidl::encoding::Context) -> usize {
2068 16
2069 }
2070 }
2071
2072 unsafe impl<D: fidl::encoding::ResourceDialect>
2073 fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D>
2074 for &WlanFullmacImplIfcSaeFrameRxRequest
2075 {
2076 #[inline]
2077 unsafe fn encode(
2078 self,
2079 encoder: &mut fidl::encoding::Encoder<'_, D>,
2080 offset: usize,
2081 _depth: fidl::encoding::Depth,
2082 ) -> fidl::Result<()> {
2083 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2084 fidl::encoding::Encode::<WlanFullmacImplIfcSaeFrameRxRequest, D>::encode(
2086 (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2087 encoder,
2088 offset,
2089 _depth,
2090 )
2091 }
2092 }
2093 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2094 fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D> for (T0,)
2095 {
2096 #[inline]
2097 unsafe fn encode(
2098 self,
2099 encoder: &mut fidl::encoding::Encoder<'_, D>,
2100 offset: usize,
2101 depth: fidl::encoding::Depth,
2102 ) -> fidl::Result<()> {
2103 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2104 self.0.encode(encoder, offset + 0, depth)?;
2108 Ok(())
2109 }
2110 }
2111
2112 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2113 for WlanFullmacImplIfcSaeFrameRxRequest
2114 {
2115 #[inline(always)]
2116 fn new_empty() -> Self {
2117 Self { frame: fidl::new_empty!(SaeFrame, D) }
2118 }
2119
2120 #[inline]
2121 unsafe fn decode(
2122 &mut self,
2123 decoder: &mut fidl::encoding::Decoder<'_, D>,
2124 offset: usize,
2125 _depth: fidl::encoding::Depth,
2126 ) -> fidl::Result<()> {
2127 decoder.debug_check_bounds::<Self>(offset);
2128 fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2130 Ok(())
2131 }
2132 }
2133
2134 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSignalReportRequest {
2135 type Borrowed<'a> = &'a Self;
2136 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2137 value
2138 }
2139 }
2140
2141 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSignalReportRequest {
2142 type Owned = Self;
2143
2144 #[inline(always)]
2145 fn inline_align(_context: fidl::encoding::Context) -> usize {
2146 1
2147 }
2148
2149 #[inline(always)]
2150 fn inline_size(_context: fidl::encoding::Context) -> usize {
2151 2
2152 }
2153 #[inline(always)]
2154 fn encode_is_copy() -> bool {
2155 true
2156 }
2157
2158 #[inline(always)]
2159 fn decode_is_copy() -> bool {
2160 true
2161 }
2162 }
2163
2164 unsafe impl<D: fidl::encoding::ResourceDialect>
2165 fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D>
2166 for &WlanFullmacImplIfcSignalReportRequest
2167 {
2168 #[inline]
2169 unsafe fn encode(
2170 self,
2171 encoder: &mut fidl::encoding::Encoder<'_, D>,
2172 offset: usize,
2173 _depth: fidl::encoding::Depth,
2174 ) -> fidl::Result<()> {
2175 encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2176 unsafe {
2177 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2179 (buf_ptr as *mut WlanFullmacImplIfcSignalReportRequest)
2180 .write_unaligned((self as *const WlanFullmacImplIfcSignalReportRequest).read());
2181 }
2184 Ok(())
2185 }
2186 }
2187 unsafe impl<
2188 D: fidl::encoding::ResourceDialect,
2189 T0: fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>,
2190 > fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D> for (T0,)
2191 {
2192 #[inline]
2193 unsafe fn encode(
2194 self,
2195 encoder: &mut fidl::encoding::Encoder<'_, D>,
2196 offset: usize,
2197 depth: fidl::encoding::Depth,
2198 ) -> fidl::Result<()> {
2199 encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2200 self.0.encode(encoder, offset + 0, depth)?;
2204 Ok(())
2205 }
2206 }
2207
2208 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2209 for WlanFullmacImplIfcSignalReportRequest
2210 {
2211 #[inline(always)]
2212 fn new_empty() -> Self {
2213 Self { ind: fidl::new_empty!(WlanFullmacSignalReportIndication, D) }
2214 }
2215
2216 #[inline]
2217 unsafe fn decode(
2218 &mut self,
2219 decoder: &mut fidl::encoding::Decoder<'_, D>,
2220 offset: usize,
2221 _depth: fidl::encoding::Depth,
2222 ) -> fidl::Result<()> {
2223 decoder.debug_check_bounds::<Self>(offset);
2224 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2225 unsafe {
2228 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2229 }
2230 Ok(())
2231 }
2232 }
2233
2234 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeFrameTxRequest {
2235 type Borrowed<'a> = &'a Self;
2236 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2237 value
2238 }
2239 }
2240
2241 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeFrameTxRequest {
2242 type Owned = Self;
2243
2244 #[inline(always)]
2245 fn inline_align(_context: fidl::encoding::Context) -> usize {
2246 8
2247 }
2248
2249 #[inline(always)]
2250 fn inline_size(_context: fidl::encoding::Context) -> usize {
2251 16
2252 }
2253 }
2254
2255 unsafe impl<D: fidl::encoding::ResourceDialect>
2256 fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D>
2257 for &WlanFullmacImplSaeFrameTxRequest
2258 {
2259 #[inline]
2260 unsafe fn encode(
2261 self,
2262 encoder: &mut fidl::encoding::Encoder<'_, D>,
2263 offset: usize,
2264 _depth: fidl::encoding::Depth,
2265 ) -> fidl::Result<()> {
2266 encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2267 fidl::encoding::Encode::<WlanFullmacImplSaeFrameTxRequest, D>::encode(
2269 (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2270 encoder,
2271 offset,
2272 _depth,
2273 )
2274 }
2275 }
2276 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2277 fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D> for (T0,)
2278 {
2279 #[inline]
2280 unsafe fn encode(
2281 self,
2282 encoder: &mut fidl::encoding::Encoder<'_, D>,
2283 offset: usize,
2284 depth: fidl::encoding::Depth,
2285 ) -> fidl::Result<()> {
2286 encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2287 self.0.encode(encoder, offset + 0, depth)?;
2291 Ok(())
2292 }
2293 }
2294
2295 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2296 for WlanFullmacImplSaeFrameTxRequest
2297 {
2298 #[inline(always)]
2299 fn new_empty() -> Self {
2300 Self { frame: fidl::new_empty!(SaeFrame, D) }
2301 }
2302
2303 #[inline]
2304 unsafe fn decode(
2305 &mut self,
2306 decoder: &mut fidl::encoding::Decoder<'_, D>,
2307 offset: usize,
2308 _depth: fidl::encoding::Depth,
2309 ) -> fidl::Result<()> {
2310 decoder.debug_check_bounds::<Self>(offset);
2311 fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2313 Ok(())
2314 }
2315 }
2316
2317 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysResponse {
2318 type Borrowed<'a> = &'a Self;
2319 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2320 value
2321 }
2322 }
2323
2324 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysResponse {
2325 type Owned = Self;
2326
2327 #[inline(always)]
2328 fn inline_align(_context: fidl::encoding::Context) -> usize {
2329 8
2330 }
2331
2332 #[inline(always)]
2333 fn inline_size(_context: fidl::encoding::Context) -> usize {
2334 16
2335 }
2336 }
2337
2338 unsafe impl<D: fidl::encoding::ResourceDialect>
2339 fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D>
2340 for &WlanFullmacImplSetKeysResponse
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::<WlanFullmacImplSetKeysResponse>(offset);
2350 fidl::encoding::Encode::<WlanFullmacImplSetKeysResponse, D>::encode(
2352 (<WlanFullmacSetKeysResp as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2353 encoder,
2354 offset,
2355 _depth,
2356 )
2357 }
2358 }
2359 unsafe impl<
2360 D: fidl::encoding::ResourceDialect,
2361 T0: fidl::encoding::Encode<WlanFullmacSetKeysResp, D>,
2362 > fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D> for (T0,)
2363 {
2364 #[inline]
2365 unsafe fn encode(
2366 self,
2367 encoder: &mut fidl::encoding::Encoder<'_, D>,
2368 offset: usize,
2369 depth: fidl::encoding::Depth,
2370 ) -> fidl::Result<()> {
2371 encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2372 self.0.encode(encoder, offset + 0, depth)?;
2376 Ok(())
2377 }
2378 }
2379
2380 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2381 for WlanFullmacImplSetKeysResponse
2382 {
2383 #[inline(always)]
2384 fn new_empty() -> Self {
2385 Self { resp: fidl::new_empty!(WlanFullmacSetKeysResp, D) }
2386 }
2387
2388 #[inline]
2389 unsafe fn decode(
2390 &mut self,
2391 decoder: &mut fidl::encoding::Decoder<'_, D>,
2392 offset: usize,
2393 _depth: fidl::encoding::Depth,
2394 ) -> fidl::Result<()> {
2395 decoder.debug_check_bounds::<Self>(offset);
2396 fidl::decode!(WlanFullmacSetKeysResp, D, &mut self.resp, decoder, offset + 0, _depth)?;
2398 Ok(())
2399 }
2400 }
2401
2402 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2403 type Borrowed<'a> = &'a Self;
2404 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2405 value
2406 }
2407 }
2408
2409 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2410 type Owned = Self;
2411
2412 #[inline(always)]
2413 fn inline_align(_context: fidl::encoding::Context) -> usize {
2414 8
2415 }
2416
2417 #[inline(always)]
2418 fn inline_size(_context: fidl::encoding::Context) -> usize {
2419 16
2420 }
2421 }
2422
2423 unsafe impl<D: fidl::encoding::ResourceDialect>
2424 fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D>
2425 for &WlanFullmacImplGetIfaceHistogramStatsResponse
2426 {
2427 #[inline]
2428 unsafe fn encode(
2429 self,
2430 encoder: &mut fidl::encoding::Encoder<'_, D>,
2431 offset: usize,
2432 _depth: fidl::encoding::Depth,
2433 ) -> fidl::Result<()> {
2434 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2435 fidl::encoding::Encode::<WlanFullmacImplGetIfaceHistogramStatsResponse, D>::encode(
2437 (
2438 <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2439 ),
2440 encoder, offset, _depth
2441 )
2442 }
2443 }
2444 unsafe impl<
2445 D: fidl::encoding::ResourceDialect,
2446 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>,
2447 > fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D> for (T0,)
2448 {
2449 #[inline]
2450 unsafe fn encode(
2451 self,
2452 encoder: &mut fidl::encoding::Encoder<'_, D>,
2453 offset: usize,
2454 depth: fidl::encoding::Depth,
2455 ) -> fidl::Result<()> {
2456 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2457 self.0.encode(encoder, offset + 0, depth)?;
2461 Ok(())
2462 }
2463 }
2464
2465 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2466 for WlanFullmacImplGetIfaceHistogramStatsResponse
2467 {
2468 #[inline(always)]
2469 fn new_empty() -> Self {
2470 Self {
2471 stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D),
2472 }
2473 }
2474
2475 #[inline]
2476 unsafe fn decode(
2477 &mut self,
2478 decoder: &mut fidl::encoding::Decoder<'_, D>,
2479 offset: usize,
2480 _depth: fidl::encoding::Depth,
2481 ) -> fidl::Result<()> {
2482 decoder.debug_check_bounds::<Self>(offset);
2483 fidl::decode!(
2485 fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
2486 D,
2487 &mut self.stats,
2488 decoder,
2489 offset + 0,
2490 _depth
2491 )?;
2492 Ok(())
2493 }
2494 }
2495
2496 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2497 type Borrowed<'a> = &'a Self;
2498 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2499 value
2500 }
2501 }
2502
2503 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2504 type Owned = Self;
2505
2506 #[inline(always)]
2507 fn inline_align(_context: fidl::encoding::Context) -> usize {
2508 8
2509 }
2510
2511 #[inline(always)]
2512 fn inline_size(_context: fidl::encoding::Context) -> usize {
2513 16
2514 }
2515 }
2516
2517 unsafe impl<D: fidl::encoding::ResourceDialect>
2518 fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D>
2519 for &WlanFullmacImplGetIfaceStatsResponse
2520 {
2521 #[inline]
2522 unsafe fn encode(
2523 self,
2524 encoder: &mut fidl::encoding::Encoder<'_, D>,
2525 offset: usize,
2526 _depth: fidl::encoding::Depth,
2527 ) -> fidl::Result<()> {
2528 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2529 fidl::encoding::Encode::<WlanFullmacImplGetIfaceStatsResponse, D>::encode(
2531 (
2532 <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2533 ),
2534 encoder, offset, _depth
2535 )
2536 }
2537 }
2538 unsafe impl<
2539 D: fidl::encoding::ResourceDialect,
2540 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceStats, D>,
2541 > fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D> for (T0,)
2542 {
2543 #[inline]
2544 unsafe fn encode(
2545 self,
2546 encoder: &mut fidl::encoding::Encoder<'_, D>,
2547 offset: usize,
2548 depth: fidl::encoding::Depth,
2549 ) -> fidl::Result<()> {
2550 encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2551 self.0.encode(encoder, offset + 0, depth)?;
2555 Ok(())
2556 }
2557 }
2558
2559 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2560 for WlanFullmacImplGetIfaceStatsResponse
2561 {
2562 #[inline(always)]
2563 fn new_empty() -> Self {
2564 Self { stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D) }
2565 }
2566
2567 #[inline]
2568 unsafe fn decode(
2569 &mut self,
2570 decoder: &mut fidl::encoding::Decoder<'_, D>,
2571 offset: usize,
2572 _depth: fidl::encoding::Depth,
2573 ) -> fidl::Result<()> {
2574 decoder.debug_check_bounds::<Self>(offset);
2575 fidl::decode!(
2577 fidl_fuchsia_wlan_stats__common::IfaceStats,
2578 D,
2579 &mut self.stats,
2580 decoder,
2581 offset + 0,
2582 _depth
2583 )?;
2584 Ok(())
2585 }
2586 }
2587
2588 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2589 type Borrowed<'a> = &'a Self;
2590 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2591 value
2592 }
2593 }
2594
2595 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2596 type Owned = Self;
2597
2598 #[inline(always)]
2599 fn inline_align(_context: fidl::encoding::Context) -> usize {
2600 1
2601 }
2602
2603 #[inline(always)]
2604 fn inline_size(_context: fidl::encoding::Context) -> usize {
2605 3
2606 }
2607 }
2608
2609 unsafe impl<D: fidl::encoding::ResourceDialect>
2610 fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D>
2611 for &WlanFullmacImplQuerySecuritySupportResponse
2612 {
2613 #[inline]
2614 unsafe fn encode(
2615 self,
2616 encoder: &mut fidl::encoding::Encoder<'_, D>,
2617 offset: usize,
2618 _depth: fidl::encoding::Depth,
2619 ) -> fidl::Result<()> {
2620 encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2621 fidl::encoding::Encode::<WlanFullmacImplQuerySecuritySupportResponse, D>::encode(
2623 (
2624 <fidl_fuchsia_wlan_common__common::SecuritySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2625 ),
2626 encoder, offset, _depth
2627 )
2628 }
2629 }
2630 unsafe impl<
2631 D: fidl::encoding::ResourceDialect,
2632 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SecuritySupport, D>,
2633 > fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D> for (T0,)
2634 {
2635 #[inline]
2636 unsafe fn encode(
2637 self,
2638 encoder: &mut fidl::encoding::Encoder<'_, D>,
2639 offset: usize,
2640 depth: fidl::encoding::Depth,
2641 ) -> fidl::Result<()> {
2642 encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2643 self.0.encode(encoder, offset + 0, depth)?;
2647 Ok(())
2648 }
2649 }
2650
2651 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2652 for WlanFullmacImplQuerySecuritySupportResponse
2653 {
2654 #[inline(always)]
2655 fn new_empty() -> Self {
2656 Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common__common::SecuritySupport, D) }
2657 }
2658
2659 #[inline]
2660 unsafe fn decode(
2661 &mut self,
2662 decoder: &mut fidl::encoding::Decoder<'_, D>,
2663 offset: usize,
2664 _depth: fidl::encoding::Depth,
2665 ) -> fidl::Result<()> {
2666 decoder.debug_check_bounds::<Self>(offset);
2667 fidl::decode!(
2669 fidl_fuchsia_wlan_common__common::SecuritySupport,
2670 D,
2671 &mut self.resp,
2672 decoder,
2673 offset + 0,
2674 _depth
2675 )?;
2676 Ok(())
2677 }
2678 }
2679
2680 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2681 type Borrowed<'a> = &'a Self;
2682 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2683 value
2684 }
2685 }
2686
2687 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2688 type Owned = Self;
2689
2690 #[inline(always)]
2691 fn inline_align(_context: fidl::encoding::Context) -> usize {
2692 1
2693 }
2694
2695 #[inline(always)]
2696 fn inline_size(_context: fidl::encoding::Context) -> usize {
2697 1
2698 }
2699 }
2700
2701 unsafe impl<D: fidl::encoding::ResourceDialect>
2702 fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2703 for &WlanFullmacImplQuerySpectrumManagementSupportResponse
2704 {
2705 #[inline]
2706 unsafe fn encode(
2707 self,
2708 encoder: &mut fidl::encoding::Encoder<'_, D>,
2709 offset: usize,
2710 _depth: fidl::encoding::Depth,
2711 ) -> fidl::Result<()> {
2712 encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2713 offset,
2714 );
2715 fidl::encoding::Encode::<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>::encode(
2717 (
2718 <fidl_fuchsia_wlan_common__common::SpectrumManagementSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2719 ),
2720 encoder, offset, _depth
2721 )
2722 }
2723 }
2724 unsafe impl<
2725 D: fidl::encoding::ResourceDialect,
2726 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SpectrumManagementSupport, D>,
2727 > fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2728 for (T0,)
2729 {
2730 #[inline]
2731 unsafe fn encode(
2732 self,
2733 encoder: &mut fidl::encoding::Encoder<'_, D>,
2734 offset: usize,
2735 depth: fidl::encoding::Depth,
2736 ) -> fidl::Result<()> {
2737 encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2738 offset,
2739 );
2740 self.0.encode(encoder, offset + 0, depth)?;
2744 Ok(())
2745 }
2746 }
2747
2748 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2749 for WlanFullmacImplQuerySpectrumManagementSupportResponse
2750 {
2751 #[inline(always)]
2752 fn new_empty() -> Self {
2753 Self {
2754 resp: fidl::new_empty!(
2755 fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2756 D
2757 ),
2758 }
2759 }
2760
2761 #[inline]
2762 unsafe fn decode(
2763 &mut self,
2764 decoder: &mut fidl::encoding::Decoder<'_, D>,
2765 offset: usize,
2766 _depth: fidl::encoding::Depth,
2767 ) -> fidl::Result<()> {
2768 decoder.debug_check_bounds::<Self>(offset);
2769 fidl::decode!(
2771 fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2772 D,
2773 &mut self.resp,
2774 decoder,
2775 offset + 0,
2776 _depth
2777 )?;
2778 Ok(())
2779 }
2780 }
2781
2782 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2783 type Borrowed<'a> = &'a Self;
2784 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2785 value
2786 }
2787 }
2788
2789 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2790 type Owned = Self;
2791
2792 #[inline(always)]
2793 fn inline_align(_context: fidl::encoding::Context) -> usize {
2794 8
2795 }
2796
2797 #[inline(always)]
2798 fn inline_size(_context: fidl::encoding::Context) -> usize {
2799 16
2800 }
2801 }
2802
2803 unsafe impl<D: fidl::encoding::ResourceDialect>
2804 fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D>
2805 for &WlanFullmacImplQueryTelemetrySupportResponse
2806 {
2807 #[inline]
2808 unsafe fn encode(
2809 self,
2810 encoder: &mut fidl::encoding::Encoder<'_, D>,
2811 offset: usize,
2812 _depth: fidl::encoding::Depth,
2813 ) -> fidl::Result<()> {
2814 encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2815 fidl::encoding::Encode::<WlanFullmacImplQueryTelemetrySupportResponse, D>::encode(
2817 (
2818 <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2819 ),
2820 encoder, offset, _depth
2821 )
2822 }
2823 }
2824 unsafe impl<
2825 D: fidl::encoding::ResourceDialect,
2826 T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
2827 > fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D> for (T0,)
2828 {
2829 #[inline]
2830 unsafe fn encode(
2831 self,
2832 encoder: &mut fidl::encoding::Encoder<'_, D>,
2833 offset: usize,
2834 depth: fidl::encoding::Depth,
2835 ) -> fidl::Result<()> {
2836 encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2837 self.0.encode(encoder, offset + 0, depth)?;
2841 Ok(())
2842 }
2843 }
2844
2845 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2846 for WlanFullmacImplQueryTelemetrySupportResponse
2847 {
2848 #[inline(always)]
2849 fn new_empty() -> Self {
2850 Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, D) }
2851 }
2852
2853 #[inline]
2854 unsafe fn decode(
2855 &mut self,
2856 decoder: &mut fidl::encoding::Decoder<'_, D>,
2857 offset: usize,
2858 _depth: fidl::encoding::Depth,
2859 ) -> fidl::Result<()> {
2860 decoder.debug_check_bounds::<Self>(offset);
2861 fidl::decode!(
2863 fidl_fuchsia_wlan_stats__common::TelemetrySupport,
2864 D,
2865 &mut self.resp,
2866 decoder,
2867 offset + 0,
2868 _depth
2869 )?;
2870 Ok(())
2871 }
2872 }
2873
2874 impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiStats {
2875 type Borrowed<'a> = &'a Self;
2876 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2877 value
2878 }
2879 }
2880
2881 unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiStats {
2882 type Owned = Self;
2883
2884 #[inline(always)]
2885 fn inline_align(_context: fidl::encoding::Context) -> usize {
2886 8
2887 }
2888
2889 #[inline(always)]
2890 fn inline_size(_context: fidl::encoding::Context) -> usize {
2891 16
2892 }
2893 }
2894
2895 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanFullmacRssiStats, D>
2896 for &WlanFullmacRssiStats
2897 {
2898 #[inline]
2899 unsafe fn encode(
2900 self,
2901 encoder: &mut fidl::encoding::Encoder<'_, D>,
2902 offset: usize,
2903 _depth: fidl::encoding::Depth,
2904 ) -> fidl::Result<()> {
2905 encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2906 fidl::encoding::Encode::<WlanFullmacRssiStats, D>::encode(
2908 (
2909 <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.hist),
2910 ),
2911 encoder, offset, _depth
2912 )
2913 }
2914 }
2915 unsafe impl<
2916 D: fidl::encoding::ResourceDialect,
2917 T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
2918 > fidl::encoding::Encode<WlanFullmacRssiStats, D> for (T0,)
2919 {
2920 #[inline]
2921 unsafe fn encode(
2922 self,
2923 encoder: &mut fidl::encoding::Encoder<'_, D>,
2924 offset: usize,
2925 depth: fidl::encoding::Depth,
2926 ) -> fidl::Result<()> {
2927 encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2928 self.0.encode(encoder, offset + 0, depth)?;
2932 Ok(())
2933 }
2934 }
2935
2936 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanFullmacRssiStats {
2937 #[inline(always)]
2938 fn new_empty() -> Self {
2939 Self { hist: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
2940 }
2941
2942 #[inline]
2943 unsafe fn decode(
2944 &mut self,
2945 decoder: &mut fidl::encoding::Decoder<'_, D>,
2946 offset: usize,
2947 _depth: fidl::encoding::Depth,
2948 ) -> fidl::Result<()> {
2949 decoder.debug_check_bounds::<Self>(offset);
2950 fidl::decode!(
2952 fidl::encoding::UnboundedVector<u64>,
2953 D,
2954 &mut self.hist,
2955 decoder,
2956 offset + 0,
2957 _depth
2958 )?;
2959 Ok(())
2960 }
2961 }
2962
2963 impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysResp {
2964 type Borrowed<'a> = &'a Self;
2965 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2966 value
2967 }
2968 }
2969
2970 unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysResp {
2971 type Owned = Self;
2972
2973 #[inline(always)]
2974 fn inline_align(_context: fidl::encoding::Context) -> usize {
2975 8
2976 }
2977
2978 #[inline(always)]
2979 fn inline_size(_context: fidl::encoding::Context) -> usize {
2980 16
2981 }
2982 }
2983
2984 unsafe impl<D: fidl::encoding::ResourceDialect>
2985 fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for &WlanFullmacSetKeysResp
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::<WlanFullmacSetKeysResp>(offset);
2995 fidl::encoding::Encode::<WlanFullmacSetKeysResp, D>::encode(
2997 (<fidl::encoding::Vector<i32, 4> as fidl::encoding::ValueTypeMarker>::borrow(
2998 &self.statuslist,
2999 ),),
3000 encoder,
3001 offset,
3002 _depth,
3003 )
3004 }
3005 }
3006 unsafe impl<
3007 D: fidl::encoding::ResourceDialect,
3008 T0: fidl::encoding::Encode<fidl::encoding::Vector<i32, 4>, D>,
3009 > fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for (T0,)
3010 {
3011 #[inline]
3012 unsafe fn encode(
3013 self,
3014 encoder: &mut fidl::encoding::Encoder<'_, D>,
3015 offset: usize,
3016 depth: fidl::encoding::Depth,
3017 ) -> fidl::Result<()> {
3018 encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3019 self.0.encode(encoder, offset + 0, depth)?;
3023 Ok(())
3024 }
3025 }
3026
3027 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3028 for WlanFullmacSetKeysResp
3029 {
3030 #[inline(always)]
3031 fn new_empty() -> Self {
3032 Self { statuslist: fidl::new_empty!(fidl::encoding::Vector<i32, 4>, D) }
3033 }
3034
3035 #[inline]
3036 unsafe fn decode(
3037 &mut self,
3038 decoder: &mut fidl::encoding::Decoder<'_, D>,
3039 offset: usize,
3040 _depth: fidl::encoding::Depth,
3041 ) -> fidl::Result<()> {
3042 decoder.debug_check_bounds::<Self>(offset);
3043 fidl::decode!(fidl::encoding::Vector<i32, 4>, D, &mut self.statuslist, decoder, offset + 0, _depth)?;
3045 Ok(())
3046 }
3047 }
3048
3049 impl fidl::encoding::ValueTypeMarker for WlanFullmacSignalReportIndication {
3050 type Borrowed<'a> = &'a Self;
3051 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3052 value
3053 }
3054 }
3055
3056 unsafe impl fidl::encoding::TypeMarker for WlanFullmacSignalReportIndication {
3057 type Owned = Self;
3058
3059 #[inline(always)]
3060 fn inline_align(_context: fidl::encoding::Context) -> usize {
3061 1
3062 }
3063
3064 #[inline(always)]
3065 fn inline_size(_context: fidl::encoding::Context) -> usize {
3066 2
3067 }
3068 #[inline(always)]
3069 fn encode_is_copy() -> bool {
3070 true
3071 }
3072
3073 #[inline(always)]
3074 fn decode_is_copy() -> bool {
3075 true
3076 }
3077 }
3078
3079 unsafe impl<D: fidl::encoding::ResourceDialect>
3080 fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>
3081 for &WlanFullmacSignalReportIndication
3082 {
3083 #[inline]
3084 unsafe fn encode(
3085 self,
3086 encoder: &mut fidl::encoding::Encoder<'_, D>,
3087 offset: usize,
3088 _depth: fidl::encoding::Depth,
3089 ) -> fidl::Result<()> {
3090 encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3091 unsafe {
3092 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3094 (buf_ptr as *mut WlanFullmacSignalReportIndication)
3095 .write_unaligned((self as *const WlanFullmacSignalReportIndication).read());
3096 }
3099 Ok(())
3100 }
3101 }
3102 unsafe impl<
3103 D: fidl::encoding::ResourceDialect,
3104 T0: fidl::encoding::Encode<i8, D>,
3105 T1: fidl::encoding::Encode<i8, D>,
3106 > fidl::encoding::Encode<WlanFullmacSignalReportIndication, D> for (T0, T1)
3107 {
3108 #[inline]
3109 unsafe fn encode(
3110 self,
3111 encoder: &mut fidl::encoding::Encoder<'_, D>,
3112 offset: usize,
3113 depth: fidl::encoding::Depth,
3114 ) -> fidl::Result<()> {
3115 encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3116 self.0.encode(encoder, offset + 0, depth)?;
3120 self.1.encode(encoder, offset + 1, depth)?;
3121 Ok(())
3122 }
3123 }
3124
3125 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3126 for WlanFullmacSignalReportIndication
3127 {
3128 #[inline(always)]
3129 fn new_empty() -> Self {
3130 Self { rssi_dbm: fidl::new_empty!(i8, D), snr_db: fidl::new_empty!(i8, D) }
3131 }
3132
3133 #[inline]
3134 unsafe fn decode(
3135 &mut self,
3136 decoder: &mut fidl::encoding::Decoder<'_, D>,
3137 offset: usize,
3138 _depth: fidl::encoding::Depth,
3139 ) -> fidl::Result<()> {
3140 decoder.debug_check_bounds::<Self>(offset);
3141 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3142 unsafe {
3145 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3146 }
3147 Ok(())
3148 }
3149 }
3150
3151 impl BandCapability {
3152 #[inline(always)]
3153 fn max_ordinal_present(&self) -> u64 {
3154 if let Some(_) = self.operating_channels {
3155 return 5;
3156 }
3157 if let Some(_) = self.vht_caps {
3158 return 4;
3159 }
3160 if let Some(_) = self.ht_caps {
3161 return 3;
3162 }
3163 if let Some(_) = self.basic_rates {
3164 return 2;
3165 }
3166 if let Some(_) = self.band {
3167 return 1;
3168 }
3169 0
3170 }
3171 }
3172
3173 impl fidl::encoding::ValueTypeMarker for BandCapability {
3174 type Borrowed<'a> = &'a Self;
3175 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3176 value
3177 }
3178 }
3179
3180 unsafe impl fidl::encoding::TypeMarker for BandCapability {
3181 type Owned = Self;
3182
3183 #[inline(always)]
3184 fn inline_align(_context: fidl::encoding::Context) -> usize {
3185 8
3186 }
3187
3188 #[inline(always)]
3189 fn inline_size(_context: fidl::encoding::Context) -> usize {
3190 16
3191 }
3192 }
3193
3194 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
3195 for &BandCapability
3196 {
3197 unsafe fn encode(
3198 self,
3199 encoder: &mut fidl::encoding::Encoder<'_, D>,
3200 offset: usize,
3201 mut depth: fidl::encoding::Depth,
3202 ) -> fidl::Result<()> {
3203 encoder.debug_check_bounds::<BandCapability>(offset);
3204 let max_ordinal: u64 = self.max_ordinal_present();
3206 encoder.write_num(max_ordinal, offset);
3207 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3208 if max_ordinal == 0 {
3210 return Ok(());
3211 }
3212 depth.increment()?;
3213 let envelope_size = 8;
3214 let bytes_len = max_ordinal as usize * envelope_size;
3215 #[allow(unused_variables)]
3216 let offset = encoder.out_of_line_offset(bytes_len);
3217 let mut _prev_end_offset: usize = 0;
3218 if 1 > max_ordinal {
3219 return Ok(());
3220 }
3221
3222 let cur_offset: usize = (1 - 1) * envelope_size;
3225
3226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3228
3229 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>(
3234 self.band.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow),
3235 encoder, offset + cur_offset, depth
3236 )?;
3237
3238 _prev_end_offset = cur_offset + envelope_size;
3239 if 2 > max_ordinal {
3240 return Ok(());
3241 }
3242
3243 let cur_offset: usize = (2 - 1) * envelope_size;
3246
3247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 12>, D>(
3255 self.basic_rates.as_ref().map(
3256 <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow,
3257 ),
3258 encoder,
3259 offset + cur_offset,
3260 depth,
3261 )?;
3262
3263 _prev_end_offset = cur_offset + envelope_size;
3264 if 3 > max_ordinal {
3265 return Ok(());
3266 }
3267
3268 let cur_offset: usize = (3 - 1) * envelope_size;
3271
3272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3274
3275 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D>(
3280 self.ht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3281 encoder, offset + cur_offset, depth
3282 )?;
3283
3284 _prev_end_offset = cur_offset + envelope_size;
3285 if 4 > max_ordinal {
3286 return Ok(());
3287 }
3288
3289 let cur_offset: usize = (4 - 1) * envelope_size;
3292
3293 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3295
3296 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D>(
3301 self.vht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3302 encoder, offset + cur_offset, depth
3303 )?;
3304
3305 _prev_end_offset = cur_offset + envelope_size;
3306 if 5 > max_ordinal {
3307 return Ok(());
3308 }
3309
3310 let cur_offset: usize = (5 - 1) * envelope_size;
3313
3314 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3316
3317 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
3322 self.operating_channels.as_ref().map(
3323 <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
3324 ),
3325 encoder,
3326 offset + cur_offset,
3327 depth,
3328 )?;
3329
3330 _prev_end_offset = cur_offset + envelope_size;
3331
3332 Ok(())
3333 }
3334 }
3335
3336 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
3337 #[inline(always)]
3338 fn new_empty() -> Self {
3339 Self::default()
3340 }
3341
3342 unsafe fn decode(
3343 &mut self,
3344 decoder: &mut fidl::encoding::Decoder<'_, D>,
3345 offset: usize,
3346 mut depth: fidl::encoding::Depth,
3347 ) -> fidl::Result<()> {
3348 decoder.debug_check_bounds::<Self>(offset);
3349 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3350 None => return Err(fidl::Error::NotNullable),
3351 Some(len) => len,
3352 };
3353 if len == 0 {
3355 return Ok(());
3356 };
3357 depth.increment()?;
3358 let envelope_size = 8;
3359 let bytes_len = len * envelope_size;
3360 let offset = decoder.out_of_line_offset(bytes_len)?;
3361 let mut _next_ordinal_to_read = 0;
3363 let mut next_offset = offset;
3364 let end_offset = offset + bytes_len;
3365 _next_ordinal_to_read += 1;
3366 if next_offset >= end_offset {
3367 return Ok(());
3368 }
3369
3370 while _next_ordinal_to_read < 1 {
3372 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3373 _next_ordinal_to_read += 1;
3374 next_offset += envelope_size;
3375 }
3376
3377 let next_out_of_line = decoder.next_out_of_line();
3378 let handles_before = decoder.remaining_handles();
3379 if let Some((inlined, num_bytes, num_handles)) =
3380 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3381 {
3382 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3383 if inlined != (member_inline_size <= 4) {
3384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3385 }
3386 let inner_offset;
3387 let mut inner_depth = depth.clone();
3388 if inlined {
3389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3390 inner_offset = next_offset;
3391 } else {
3392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3393 inner_depth.increment()?;
3394 }
3395 let val_ref = self.band.get_or_insert_with(|| {
3396 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D)
3397 });
3398 fidl::decode!(
3399 fidl_fuchsia_wlan_ieee80211__common::WlanBand,
3400 D,
3401 val_ref,
3402 decoder,
3403 inner_offset,
3404 inner_depth
3405 )?;
3406 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3407 {
3408 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3409 }
3410 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3411 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3412 }
3413 }
3414
3415 next_offset += envelope_size;
3416 _next_ordinal_to_read += 1;
3417 if next_offset >= end_offset {
3418 return Ok(());
3419 }
3420
3421 while _next_ordinal_to_read < 2 {
3423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3424 _next_ordinal_to_read += 1;
3425 next_offset += envelope_size;
3426 }
3427
3428 let next_out_of_line = decoder.next_out_of_line();
3429 let handles_before = decoder.remaining_handles();
3430 if let Some((inlined, num_bytes, num_handles)) =
3431 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3432 {
3433 let member_inline_size =
3434 <fidl::encoding::Vector<u8, 12> as fidl::encoding::TypeMarker>::inline_size(
3435 decoder.context,
3436 );
3437 if inlined != (member_inline_size <= 4) {
3438 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3439 }
3440 let inner_offset;
3441 let mut inner_depth = depth.clone();
3442 if inlined {
3443 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3444 inner_offset = next_offset;
3445 } else {
3446 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3447 inner_depth.increment()?;
3448 }
3449 let val_ref = self
3450 .basic_rates
3451 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D));
3452 fidl::decode!(fidl::encoding::Vector<u8, 12>, D, val_ref, decoder, inner_offset, inner_depth)?;
3453 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3454 {
3455 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3456 }
3457 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3458 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3459 }
3460 }
3461
3462 next_offset += envelope_size;
3463 _next_ordinal_to_read += 1;
3464 if next_offset >= end_offset {
3465 return Ok(());
3466 }
3467
3468 while _next_ordinal_to_read < 3 {
3470 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3471 _next_ordinal_to_read += 1;
3472 next_offset += envelope_size;
3473 }
3474
3475 let next_out_of_line = decoder.next_out_of_line();
3476 let handles_before = decoder.remaining_handles();
3477 if let Some((inlined, num_bytes, num_handles)) =
3478 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3479 {
3480 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3481 if inlined != (member_inline_size <= 4) {
3482 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3483 }
3484 let inner_offset;
3485 let mut inner_depth = depth.clone();
3486 if inlined {
3487 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3488 inner_offset = next_offset;
3489 } else {
3490 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3491 inner_depth.increment()?;
3492 }
3493 let val_ref = self.ht_caps.get_or_insert_with(|| {
3494 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D)
3495 });
3496 fidl::decode!(
3497 fidl_fuchsia_wlan_ieee80211__common::HtCapabilities,
3498 D,
3499 val_ref,
3500 decoder,
3501 inner_offset,
3502 inner_depth
3503 )?;
3504 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3505 {
3506 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3507 }
3508 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3509 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3510 }
3511 }
3512
3513 next_offset += envelope_size;
3514 _next_ordinal_to_read += 1;
3515 if next_offset >= end_offset {
3516 return Ok(());
3517 }
3518
3519 while _next_ordinal_to_read < 4 {
3521 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3522 _next_ordinal_to_read += 1;
3523 next_offset += envelope_size;
3524 }
3525
3526 let next_out_of_line = decoder.next_out_of_line();
3527 let handles_before = decoder.remaining_handles();
3528 if let Some((inlined, num_bytes, num_handles)) =
3529 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3530 {
3531 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3532 if inlined != (member_inline_size <= 4) {
3533 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3534 }
3535 let inner_offset;
3536 let mut inner_depth = depth.clone();
3537 if inlined {
3538 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3539 inner_offset = next_offset;
3540 } else {
3541 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3542 inner_depth.increment()?;
3543 }
3544 let val_ref = self.vht_caps.get_or_insert_with(|| {
3545 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D)
3546 });
3547 fidl::decode!(
3548 fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities,
3549 D,
3550 val_ref,
3551 decoder,
3552 inner_offset,
3553 inner_depth
3554 )?;
3555 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3556 {
3557 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3558 }
3559 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3560 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3561 }
3562 }
3563
3564 next_offset += envelope_size;
3565 _next_ordinal_to_read += 1;
3566 if next_offset >= end_offset {
3567 return Ok(());
3568 }
3569
3570 while _next_ordinal_to_read < 5 {
3572 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3573 _next_ordinal_to_read += 1;
3574 next_offset += envelope_size;
3575 }
3576
3577 let next_out_of_line = decoder.next_out_of_line();
3578 let handles_before = decoder.remaining_handles();
3579 if let Some((inlined, num_bytes, num_handles)) =
3580 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3581 {
3582 let member_inline_size =
3583 <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
3584 decoder.context,
3585 );
3586 if inlined != (member_inline_size <= 4) {
3587 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3588 }
3589 let inner_offset;
3590 let mut inner_depth = depth.clone();
3591 if inlined {
3592 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3593 inner_offset = next_offset;
3594 } else {
3595 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3596 inner_depth.increment()?;
3597 }
3598 let val_ref = self
3599 .operating_channels
3600 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
3601 fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
3602 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3603 {
3604 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3605 }
3606 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3607 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3608 }
3609 }
3610
3611 next_offset += envelope_size;
3612
3613 while next_offset < end_offset {
3615 _next_ordinal_to_read += 1;
3616 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3617 next_offset += envelope_size;
3618 }
3619
3620 Ok(())
3621 }
3622 }
3623
3624 impl SaeFrame {
3625 #[inline(always)]
3626 fn max_ordinal_present(&self) -> u64 {
3627 if let Some(_) = self.sae_fields {
3628 return 4;
3629 }
3630 if let Some(_) = self.seq_num {
3631 return 3;
3632 }
3633 if let Some(_) = self.status_code {
3634 return 2;
3635 }
3636 if let Some(_) = self.peer_sta_address {
3637 return 1;
3638 }
3639 0
3640 }
3641 }
3642
3643 impl fidl::encoding::ValueTypeMarker for SaeFrame {
3644 type Borrowed<'a> = &'a Self;
3645 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3646 value
3647 }
3648 }
3649
3650 unsafe impl fidl::encoding::TypeMarker for SaeFrame {
3651 type Owned = Self;
3652
3653 #[inline(always)]
3654 fn inline_align(_context: fidl::encoding::Context) -> usize {
3655 8
3656 }
3657
3658 #[inline(always)]
3659 fn inline_size(_context: fidl::encoding::Context) -> usize {
3660 16
3661 }
3662 }
3663
3664 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
3665 unsafe fn encode(
3666 self,
3667 encoder: &mut fidl::encoding::Encoder<'_, D>,
3668 offset: usize,
3669 mut depth: fidl::encoding::Depth,
3670 ) -> fidl::Result<()> {
3671 encoder.debug_check_bounds::<SaeFrame>(offset);
3672 let max_ordinal: u64 = self.max_ordinal_present();
3674 encoder.write_num(max_ordinal, offset);
3675 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3676 if max_ordinal == 0 {
3678 return Ok(());
3679 }
3680 depth.increment()?;
3681 let envelope_size = 8;
3682 let bytes_len = max_ordinal as usize * envelope_size;
3683 #[allow(unused_variables)]
3684 let offset = encoder.out_of_line_offset(bytes_len);
3685 let mut _prev_end_offset: usize = 0;
3686 if 1 > max_ordinal {
3687 return Ok(());
3688 }
3689
3690 let cur_offset: usize = (1 - 1) * envelope_size;
3693
3694 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3696
3697 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3702 self.peer_sta_address
3703 .as_ref()
3704 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3705 encoder,
3706 offset + cur_offset,
3707 depth,
3708 )?;
3709
3710 _prev_end_offset = cur_offset + envelope_size;
3711 if 2 > max_ordinal {
3712 return Ok(());
3713 }
3714
3715 let cur_offset: usize = (2 - 1) * envelope_size;
3718
3719 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3721
3722 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
3727 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
3728 encoder, offset + cur_offset, depth
3729 )?;
3730
3731 _prev_end_offset = cur_offset + envelope_size;
3732 if 3 > max_ordinal {
3733 return Ok(());
3734 }
3735
3736 let cur_offset: usize = (3 - 1) * envelope_size;
3739
3740 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3742
3743 fidl::encoding::encode_in_envelope_optional::<u16, D>(
3748 self.seq_num.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3749 encoder,
3750 offset + cur_offset,
3751 depth,
3752 )?;
3753
3754 _prev_end_offset = cur_offset + envelope_size;
3755 if 4 > max_ordinal {
3756 return Ok(());
3757 }
3758
3759 let cur_offset: usize = (4 - 1) * envelope_size;
3762
3763 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3765
3766 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3771 self.sae_fields.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3772 encoder, offset + cur_offset, depth
3773 )?;
3774
3775 _prev_end_offset = cur_offset + envelope_size;
3776
3777 Ok(())
3778 }
3779 }
3780
3781 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
3782 #[inline(always)]
3783 fn new_empty() -> Self {
3784 Self::default()
3785 }
3786
3787 unsafe fn decode(
3788 &mut self,
3789 decoder: &mut fidl::encoding::Decoder<'_, D>,
3790 offset: usize,
3791 mut depth: fidl::encoding::Depth,
3792 ) -> fidl::Result<()> {
3793 decoder.debug_check_bounds::<Self>(offset);
3794 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3795 None => return Err(fidl::Error::NotNullable),
3796 Some(len) => len,
3797 };
3798 if len == 0 {
3800 return Ok(());
3801 };
3802 depth.increment()?;
3803 let envelope_size = 8;
3804 let bytes_len = len * envelope_size;
3805 let offset = decoder.out_of_line_offset(bytes_len)?;
3806 let mut _next_ordinal_to_read = 0;
3808 let mut next_offset = offset;
3809 let end_offset = offset + bytes_len;
3810 _next_ordinal_to_read += 1;
3811 if next_offset >= end_offset {
3812 return Ok(());
3813 }
3814
3815 while _next_ordinal_to_read < 1 {
3817 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3818 _next_ordinal_to_read += 1;
3819 next_offset += envelope_size;
3820 }
3821
3822 let next_out_of_line = decoder.next_out_of_line();
3823 let handles_before = decoder.remaining_handles();
3824 if let Some((inlined, num_bytes, num_handles)) =
3825 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3826 {
3827 let member_inline_size =
3828 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3829 decoder.context,
3830 );
3831 if inlined != (member_inline_size <= 4) {
3832 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3833 }
3834 let inner_offset;
3835 let mut inner_depth = depth.clone();
3836 if inlined {
3837 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3838 inner_offset = next_offset;
3839 } else {
3840 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3841 inner_depth.increment()?;
3842 }
3843 let val_ref = self
3844 .peer_sta_address
3845 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3846 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3847 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848 {
3849 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850 }
3851 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853 }
3854 }
3855
3856 next_offset += envelope_size;
3857 _next_ordinal_to_read += 1;
3858 if next_offset >= end_offset {
3859 return Ok(());
3860 }
3861
3862 while _next_ordinal_to_read < 2 {
3864 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3865 _next_ordinal_to_read += 1;
3866 next_offset += envelope_size;
3867 }
3868
3869 let next_out_of_line = decoder.next_out_of_line();
3870 let handles_before = decoder.remaining_handles();
3871 if let Some((inlined, num_bytes, num_handles)) =
3872 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3873 {
3874 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3875 if inlined != (member_inline_size <= 4) {
3876 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3877 }
3878 let inner_offset;
3879 let mut inner_depth = depth.clone();
3880 if inlined {
3881 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3882 inner_offset = next_offset;
3883 } else {
3884 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3885 inner_depth.increment()?;
3886 }
3887 let val_ref = self.status_code.get_or_insert_with(|| {
3888 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
3889 });
3890 fidl::decode!(
3891 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
3892 D,
3893 val_ref,
3894 decoder,
3895 inner_offset,
3896 inner_depth
3897 )?;
3898 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3899 {
3900 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3901 }
3902 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3903 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3904 }
3905 }
3906
3907 next_offset += envelope_size;
3908 _next_ordinal_to_read += 1;
3909 if next_offset >= end_offset {
3910 return Ok(());
3911 }
3912
3913 while _next_ordinal_to_read < 3 {
3915 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3916 _next_ordinal_to_read += 1;
3917 next_offset += envelope_size;
3918 }
3919
3920 let next_out_of_line = decoder.next_out_of_line();
3921 let handles_before = decoder.remaining_handles();
3922 if let Some((inlined, num_bytes, num_handles)) =
3923 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3924 {
3925 let member_inline_size =
3926 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3927 if inlined != (member_inline_size <= 4) {
3928 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3929 }
3930 let inner_offset;
3931 let mut inner_depth = depth.clone();
3932 if inlined {
3933 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3934 inner_offset = next_offset;
3935 } else {
3936 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3937 inner_depth.increment()?;
3938 }
3939 let val_ref = self.seq_num.get_or_insert_with(|| fidl::new_empty!(u16, D));
3940 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3941 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3942 {
3943 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3944 }
3945 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3946 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3947 }
3948 }
3949
3950 next_offset += envelope_size;
3951 _next_ordinal_to_read += 1;
3952 if next_offset >= end_offset {
3953 return Ok(());
3954 }
3955
3956 while _next_ordinal_to_read < 4 {
3958 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3959 _next_ordinal_to_read += 1;
3960 next_offset += envelope_size;
3961 }
3962
3963 let next_out_of_line = decoder.next_out_of_line();
3964 let handles_before = decoder.remaining_handles();
3965 if let Some((inlined, num_bytes, num_handles)) =
3966 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3967 {
3968 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3969 if inlined != (member_inline_size <= 4) {
3970 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3971 }
3972 let inner_offset;
3973 let mut inner_depth = depth.clone();
3974 if inlined {
3975 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3976 inner_offset = next_offset;
3977 } else {
3978 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3979 inner_depth.increment()?;
3980 }
3981 let val_ref = self.sae_fields.get_or_insert_with(|| {
3982 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
3983 });
3984 fidl::decode!(
3985 fidl::encoding::UnboundedVector<u8>,
3986 D,
3987 val_ref,
3988 decoder,
3989 inner_offset,
3990 inner_depth
3991 )?;
3992 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3993 {
3994 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3995 }
3996 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3997 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3998 }
3999 }
4000
4001 next_offset += envelope_size;
4002
4003 while next_offset < end_offset {
4005 _next_ordinal_to_read += 1;
4006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4007 next_offset += envelope_size;
4008 }
4009
4010 Ok(())
4011 }
4012 }
4013
4014 impl WlanFullmacImplAssocRespRequest {
4015 #[inline(always)]
4016 fn max_ordinal_present(&self) -> u64 {
4017 if let Some(_) = self.association_id {
4018 return 3;
4019 }
4020 if let Some(_) = self.result_code {
4021 return 2;
4022 }
4023 if let Some(_) = self.peer_sta_address {
4024 return 1;
4025 }
4026 0
4027 }
4028 }
4029
4030 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAssocRespRequest {
4031 type Borrowed<'a> = &'a Self;
4032 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4033 value
4034 }
4035 }
4036
4037 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAssocRespRequest {
4038 type Owned = Self;
4039
4040 #[inline(always)]
4041 fn inline_align(_context: fidl::encoding::Context) -> usize {
4042 8
4043 }
4044
4045 #[inline(always)]
4046 fn inline_size(_context: fidl::encoding::Context) -> usize {
4047 16
4048 }
4049 }
4050
4051 unsafe impl<D: fidl::encoding::ResourceDialect>
4052 fidl::encoding::Encode<WlanFullmacImplAssocRespRequest, D>
4053 for &WlanFullmacImplAssocRespRequest
4054 {
4055 unsafe fn encode(
4056 self,
4057 encoder: &mut fidl::encoding::Encoder<'_, D>,
4058 offset: usize,
4059 mut depth: fidl::encoding::Depth,
4060 ) -> fidl::Result<()> {
4061 encoder.debug_check_bounds::<WlanFullmacImplAssocRespRequest>(offset);
4062 let max_ordinal: u64 = self.max_ordinal_present();
4064 encoder.write_num(max_ordinal, offset);
4065 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4066 if max_ordinal == 0 {
4068 return Ok(());
4069 }
4070 depth.increment()?;
4071 let envelope_size = 8;
4072 let bytes_len = max_ordinal as usize * envelope_size;
4073 #[allow(unused_variables)]
4074 let offset = encoder.out_of_line_offset(bytes_len);
4075 let mut _prev_end_offset: usize = 0;
4076 if 1 > max_ordinal {
4077 return Ok(());
4078 }
4079
4080 let cur_offset: usize = (1 - 1) * envelope_size;
4083
4084 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4086
4087 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4092 self.peer_sta_address
4093 .as_ref()
4094 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4095 encoder,
4096 offset + cur_offset,
4097 depth,
4098 )?;
4099
4100 _prev_end_offset = cur_offset + envelope_size;
4101 if 2 > max_ordinal {
4102 return Ok(());
4103 }
4104
4105 let cur_offset: usize = (2 - 1) * envelope_size;
4108
4109 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4111
4112 fidl::encoding::encode_in_envelope_optional::<WlanAssocResult, D>(
4117 self.result_code
4118 .as_ref()
4119 .map(<WlanAssocResult as fidl::encoding::ValueTypeMarker>::borrow),
4120 encoder,
4121 offset + cur_offset,
4122 depth,
4123 )?;
4124
4125 _prev_end_offset = cur_offset + envelope_size;
4126 if 3 > max_ordinal {
4127 return Ok(());
4128 }
4129
4130 let cur_offset: usize = (3 - 1) * envelope_size;
4133
4134 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4136
4137 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4142 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4143 encoder,
4144 offset + cur_offset,
4145 depth,
4146 )?;
4147
4148 _prev_end_offset = cur_offset + envelope_size;
4149
4150 Ok(())
4151 }
4152 }
4153
4154 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4155 for WlanFullmacImplAssocRespRequest
4156 {
4157 #[inline(always)]
4158 fn new_empty() -> Self {
4159 Self::default()
4160 }
4161
4162 unsafe fn decode(
4163 &mut self,
4164 decoder: &mut fidl::encoding::Decoder<'_, D>,
4165 offset: usize,
4166 mut depth: fidl::encoding::Depth,
4167 ) -> fidl::Result<()> {
4168 decoder.debug_check_bounds::<Self>(offset);
4169 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4170 None => return Err(fidl::Error::NotNullable),
4171 Some(len) => len,
4172 };
4173 if len == 0 {
4175 return Ok(());
4176 };
4177 depth.increment()?;
4178 let envelope_size = 8;
4179 let bytes_len = len * envelope_size;
4180 let offset = decoder.out_of_line_offset(bytes_len)?;
4181 let mut _next_ordinal_to_read = 0;
4183 let mut next_offset = offset;
4184 let end_offset = offset + bytes_len;
4185 _next_ordinal_to_read += 1;
4186 if next_offset >= end_offset {
4187 return Ok(());
4188 }
4189
4190 while _next_ordinal_to_read < 1 {
4192 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4193 _next_ordinal_to_read += 1;
4194 next_offset += envelope_size;
4195 }
4196
4197 let next_out_of_line = decoder.next_out_of_line();
4198 let handles_before = decoder.remaining_handles();
4199 if let Some((inlined, num_bytes, num_handles)) =
4200 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4201 {
4202 let member_inline_size =
4203 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4204 decoder.context,
4205 );
4206 if inlined != (member_inline_size <= 4) {
4207 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4208 }
4209 let inner_offset;
4210 let mut inner_depth = depth.clone();
4211 if inlined {
4212 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4213 inner_offset = next_offset;
4214 } else {
4215 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4216 inner_depth.increment()?;
4217 }
4218 let val_ref = self
4219 .peer_sta_address
4220 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4221 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4222 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4223 {
4224 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4225 }
4226 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4227 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4228 }
4229 }
4230
4231 next_offset += envelope_size;
4232 _next_ordinal_to_read += 1;
4233 if next_offset >= end_offset {
4234 return Ok(());
4235 }
4236
4237 while _next_ordinal_to_read < 2 {
4239 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4240 _next_ordinal_to_read += 1;
4241 next_offset += envelope_size;
4242 }
4243
4244 let next_out_of_line = decoder.next_out_of_line();
4245 let handles_before = decoder.remaining_handles();
4246 if let Some((inlined, num_bytes, num_handles)) =
4247 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4248 {
4249 let member_inline_size =
4250 <WlanAssocResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4251 if inlined != (member_inline_size <= 4) {
4252 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4253 }
4254 let inner_offset;
4255 let mut inner_depth = depth.clone();
4256 if inlined {
4257 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4258 inner_offset = next_offset;
4259 } else {
4260 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4261 inner_depth.increment()?;
4262 }
4263 let val_ref =
4264 self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAssocResult, D));
4265 fidl::decode!(WlanAssocResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4266 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4267 {
4268 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4269 }
4270 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4271 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4272 }
4273 }
4274
4275 next_offset += envelope_size;
4276 _next_ordinal_to_read += 1;
4277 if next_offset >= end_offset {
4278 return Ok(());
4279 }
4280
4281 while _next_ordinal_to_read < 3 {
4283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4284 _next_ordinal_to_read += 1;
4285 next_offset += envelope_size;
4286 }
4287
4288 let next_out_of_line = decoder.next_out_of_line();
4289 let handles_before = decoder.remaining_handles();
4290 if let Some((inlined, num_bytes, num_handles)) =
4291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4292 {
4293 let member_inline_size =
4294 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4295 if inlined != (member_inline_size <= 4) {
4296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4297 }
4298 let inner_offset;
4299 let mut inner_depth = depth.clone();
4300 if inlined {
4301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4302 inner_offset = next_offset;
4303 } else {
4304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4305 inner_depth.increment()?;
4306 }
4307 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4308 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4309 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4310 {
4311 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4312 }
4313 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4314 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4315 }
4316 }
4317
4318 next_offset += envelope_size;
4319
4320 while next_offset < end_offset {
4322 _next_ordinal_to_read += 1;
4323 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4324 next_offset += envelope_size;
4325 }
4326
4327 Ok(())
4328 }
4329 }
4330
4331 impl WlanFullmacImplAuthRespRequest {
4332 #[inline(always)]
4333 fn max_ordinal_present(&self) -> u64 {
4334 if let Some(_) = self.result_code {
4335 return 2;
4336 }
4337 if let Some(_) = self.peer_sta_address {
4338 return 1;
4339 }
4340 0
4341 }
4342 }
4343
4344 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAuthRespRequest {
4345 type Borrowed<'a> = &'a Self;
4346 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4347 value
4348 }
4349 }
4350
4351 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAuthRespRequest {
4352 type Owned = Self;
4353
4354 #[inline(always)]
4355 fn inline_align(_context: fidl::encoding::Context) -> usize {
4356 8
4357 }
4358
4359 #[inline(always)]
4360 fn inline_size(_context: fidl::encoding::Context) -> usize {
4361 16
4362 }
4363 }
4364
4365 unsafe impl<D: fidl::encoding::ResourceDialect>
4366 fidl::encoding::Encode<WlanFullmacImplAuthRespRequest, D>
4367 for &WlanFullmacImplAuthRespRequest
4368 {
4369 unsafe fn encode(
4370 self,
4371 encoder: &mut fidl::encoding::Encoder<'_, D>,
4372 offset: usize,
4373 mut depth: fidl::encoding::Depth,
4374 ) -> fidl::Result<()> {
4375 encoder.debug_check_bounds::<WlanFullmacImplAuthRespRequest>(offset);
4376 let max_ordinal: u64 = self.max_ordinal_present();
4378 encoder.write_num(max_ordinal, offset);
4379 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4380 if max_ordinal == 0 {
4382 return Ok(());
4383 }
4384 depth.increment()?;
4385 let envelope_size = 8;
4386 let bytes_len = max_ordinal as usize * envelope_size;
4387 #[allow(unused_variables)]
4388 let offset = encoder.out_of_line_offset(bytes_len);
4389 let mut _prev_end_offset: usize = 0;
4390 if 1 > max_ordinal {
4391 return Ok(());
4392 }
4393
4394 let cur_offset: usize = (1 - 1) * envelope_size;
4397
4398 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4400
4401 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4406 self.peer_sta_address
4407 .as_ref()
4408 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4409 encoder,
4410 offset + cur_offset,
4411 depth,
4412 )?;
4413
4414 _prev_end_offset = cur_offset + envelope_size;
4415 if 2 > max_ordinal {
4416 return Ok(());
4417 }
4418
4419 let cur_offset: usize = (2 - 1) * envelope_size;
4422
4423 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4425
4426 fidl::encoding::encode_in_envelope_optional::<WlanAuthResult, D>(
4431 self.result_code
4432 .as_ref()
4433 .map(<WlanAuthResult as fidl::encoding::ValueTypeMarker>::borrow),
4434 encoder,
4435 offset + cur_offset,
4436 depth,
4437 )?;
4438
4439 _prev_end_offset = cur_offset + envelope_size;
4440
4441 Ok(())
4442 }
4443 }
4444
4445 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4446 for WlanFullmacImplAuthRespRequest
4447 {
4448 #[inline(always)]
4449 fn new_empty() -> Self {
4450 Self::default()
4451 }
4452
4453 unsafe fn decode(
4454 &mut self,
4455 decoder: &mut fidl::encoding::Decoder<'_, D>,
4456 offset: usize,
4457 mut depth: fidl::encoding::Depth,
4458 ) -> fidl::Result<()> {
4459 decoder.debug_check_bounds::<Self>(offset);
4460 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4461 None => return Err(fidl::Error::NotNullable),
4462 Some(len) => len,
4463 };
4464 if len == 0 {
4466 return Ok(());
4467 };
4468 depth.increment()?;
4469 let envelope_size = 8;
4470 let bytes_len = len * envelope_size;
4471 let offset = decoder.out_of_line_offset(bytes_len)?;
4472 let mut _next_ordinal_to_read = 0;
4474 let mut next_offset = offset;
4475 let end_offset = offset + bytes_len;
4476 _next_ordinal_to_read += 1;
4477 if next_offset >= end_offset {
4478 return Ok(());
4479 }
4480
4481 while _next_ordinal_to_read < 1 {
4483 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4484 _next_ordinal_to_read += 1;
4485 next_offset += envelope_size;
4486 }
4487
4488 let next_out_of_line = decoder.next_out_of_line();
4489 let handles_before = decoder.remaining_handles();
4490 if let Some((inlined, num_bytes, num_handles)) =
4491 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4492 {
4493 let member_inline_size =
4494 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4495 decoder.context,
4496 );
4497 if inlined != (member_inline_size <= 4) {
4498 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4499 }
4500 let inner_offset;
4501 let mut inner_depth = depth.clone();
4502 if inlined {
4503 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4504 inner_offset = next_offset;
4505 } else {
4506 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4507 inner_depth.increment()?;
4508 }
4509 let val_ref = self
4510 .peer_sta_address
4511 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4512 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4513 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4514 {
4515 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4516 }
4517 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4518 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4519 }
4520 }
4521
4522 next_offset += envelope_size;
4523 _next_ordinal_to_read += 1;
4524 if next_offset >= end_offset {
4525 return Ok(());
4526 }
4527
4528 while _next_ordinal_to_read < 2 {
4530 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4531 _next_ordinal_to_read += 1;
4532 next_offset += envelope_size;
4533 }
4534
4535 let next_out_of_line = decoder.next_out_of_line();
4536 let handles_before = decoder.remaining_handles();
4537 if let Some((inlined, num_bytes, num_handles)) =
4538 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4539 {
4540 let member_inline_size =
4541 <WlanAuthResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4542 if inlined != (member_inline_size <= 4) {
4543 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4544 }
4545 let inner_offset;
4546 let mut inner_depth = depth.clone();
4547 if inlined {
4548 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4549 inner_offset = next_offset;
4550 } else {
4551 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4552 inner_depth.increment()?;
4553 }
4554 let val_ref =
4555 self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAuthResult, D));
4556 fidl::decode!(WlanAuthResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4557 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4558 {
4559 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4560 }
4561 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4562 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4563 }
4564 }
4565
4566 next_offset += envelope_size;
4567
4568 while next_offset < end_offset {
4570 _next_ordinal_to_read += 1;
4571 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4572 next_offset += envelope_size;
4573 }
4574
4575 Ok(())
4576 }
4577 }
4578
4579 impl WlanFullmacImplConnectRequest {
4580 #[inline(always)]
4581 fn max_ordinal_present(&self) -> u64 {
4582 if let Some(_) = self.wep_key_desc {
4583 return 7;
4584 }
4585 if let Some(_) = self.security_ie {
4586 return 6;
4587 }
4588 if let Some(_) = self.wep_key {
4589 return 5;
4590 }
4591 if let Some(_) = self.sae_password {
4592 return 4;
4593 }
4594 if let Some(_) = self.auth_type {
4595 return 3;
4596 }
4597 if let Some(_) = self.connect_failure_timeout {
4598 return 2;
4599 }
4600 if let Some(_) = self.selected_bss {
4601 return 1;
4602 }
4603 0
4604 }
4605 }
4606
4607 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplConnectRequest {
4608 type Borrowed<'a> = &'a Self;
4609 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4610 value
4611 }
4612 }
4613
4614 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplConnectRequest {
4615 type Owned = Self;
4616
4617 #[inline(always)]
4618 fn inline_align(_context: fidl::encoding::Context) -> usize {
4619 8
4620 }
4621
4622 #[inline(always)]
4623 fn inline_size(_context: fidl::encoding::Context) -> usize {
4624 16
4625 }
4626 }
4627
4628 unsafe impl<D: fidl::encoding::ResourceDialect>
4629 fidl::encoding::Encode<WlanFullmacImplConnectRequest, D>
4630 for &WlanFullmacImplConnectRequest
4631 {
4632 unsafe fn encode(
4633 self,
4634 encoder: &mut fidl::encoding::Encoder<'_, D>,
4635 offset: usize,
4636 mut depth: fidl::encoding::Depth,
4637 ) -> fidl::Result<()> {
4638 encoder.debug_check_bounds::<WlanFullmacImplConnectRequest>(offset);
4639 let max_ordinal: u64 = self.max_ordinal_present();
4641 encoder.write_num(max_ordinal, offset);
4642 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4643 if max_ordinal == 0 {
4645 return Ok(());
4646 }
4647 depth.increment()?;
4648 let envelope_size = 8;
4649 let bytes_len = max_ordinal as usize * envelope_size;
4650 #[allow(unused_variables)]
4651 let offset = encoder.out_of_line_offset(bytes_len);
4652 let mut _prev_end_offset: usize = 0;
4653 if 1 > max_ordinal {
4654 return Ok(());
4655 }
4656
4657 let cur_offset: usize = (1 - 1) * envelope_size;
4660
4661 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4663
4664 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
4669 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
4670 encoder, offset + cur_offset, depth
4671 )?;
4672
4673 _prev_end_offset = cur_offset + envelope_size;
4674 if 2 > max_ordinal {
4675 return Ok(());
4676 }
4677
4678 let cur_offset: usize = (2 - 1) * envelope_size;
4681
4682 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4684
4685 fidl::encoding::encode_in_envelope_optional::<u32, D>(
4690 self.connect_failure_timeout
4691 .as_ref()
4692 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4693 encoder,
4694 offset + cur_offset,
4695 depth,
4696 )?;
4697
4698 _prev_end_offset = cur_offset + envelope_size;
4699 if 3 > max_ordinal {
4700 return Ok(());
4701 }
4702
4703 let cur_offset: usize = (3 - 1) * envelope_size;
4706
4707 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4709
4710 fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
4715 self.auth_type
4716 .as_ref()
4717 .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
4718 encoder,
4719 offset + cur_offset,
4720 depth,
4721 )?;
4722
4723 _prev_end_offset = cur_offset + envelope_size;
4724 if 4 > max_ordinal {
4725 return Ok(());
4726 }
4727
4728 let cur_offset: usize = (4 - 1) * envelope_size;
4731
4732 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4734
4735 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4740 self.sae_password.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4741 encoder, offset + cur_offset, depth
4742 )?;
4743
4744 _prev_end_offset = cur_offset + envelope_size;
4745 if 5 > max_ordinal {
4746 return Ok(());
4747 }
4748
4749 let cur_offset: usize = (5 - 1) * envelope_size;
4752
4753 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4755
4756 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanKeyConfig, D>(
4761 self.wep_key.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::ValueTypeMarker>::borrow),
4762 encoder, offset + cur_offset, depth
4763 )?;
4764
4765 _prev_end_offset = cur_offset + envelope_size;
4766 if 6 > max_ordinal {
4767 return Ok(());
4768 }
4769
4770 let cur_offset: usize = (6 - 1) * envelope_size;
4773
4774 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4776
4777 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
4782 self.security_ie.as_ref().map(
4783 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
4784 ),
4785 encoder,
4786 offset + cur_offset,
4787 depth,
4788 )?;
4789
4790 _prev_end_offset = cur_offset + envelope_size;
4791 if 7 > max_ordinal {
4792 return Ok(());
4793 }
4794
4795 let cur_offset: usize = (7 - 1) * envelope_size;
4798
4799 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4801
4802 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D>(
4807 self.wep_key_desc.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::ValueTypeMarker>::borrow),
4808 encoder, offset + cur_offset, depth
4809 )?;
4810
4811 _prev_end_offset = cur_offset + envelope_size;
4812
4813 Ok(())
4814 }
4815 }
4816
4817 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4818 for WlanFullmacImplConnectRequest
4819 {
4820 #[inline(always)]
4821 fn new_empty() -> Self {
4822 Self::default()
4823 }
4824
4825 unsafe fn decode(
4826 &mut self,
4827 decoder: &mut fidl::encoding::Decoder<'_, D>,
4828 offset: usize,
4829 mut depth: fidl::encoding::Depth,
4830 ) -> fidl::Result<()> {
4831 decoder.debug_check_bounds::<Self>(offset);
4832 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4833 None => return Err(fidl::Error::NotNullable),
4834 Some(len) => len,
4835 };
4836 if len == 0 {
4838 return Ok(());
4839 };
4840 depth.increment()?;
4841 let envelope_size = 8;
4842 let bytes_len = len * envelope_size;
4843 let offset = decoder.out_of_line_offset(bytes_len)?;
4844 let mut _next_ordinal_to_read = 0;
4846 let mut next_offset = offset;
4847 let end_offset = offset + bytes_len;
4848 _next_ordinal_to_read += 1;
4849 if next_offset >= end_offset {
4850 return Ok(());
4851 }
4852
4853 while _next_ordinal_to_read < 1 {
4855 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4856 _next_ordinal_to_read += 1;
4857 next_offset += envelope_size;
4858 }
4859
4860 let next_out_of_line = decoder.next_out_of_line();
4861 let handles_before = decoder.remaining_handles();
4862 if let Some((inlined, num_bytes, num_handles)) =
4863 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4864 {
4865 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4866 if inlined != (member_inline_size <= 4) {
4867 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4868 }
4869 let inner_offset;
4870 let mut inner_depth = depth.clone();
4871 if inlined {
4872 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4873 inner_offset = next_offset;
4874 } else {
4875 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4876 inner_depth.increment()?;
4877 }
4878 let val_ref = self.selected_bss.get_or_insert_with(|| {
4879 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
4880 });
4881 fidl::decode!(
4882 fidl_fuchsia_wlan_common__common::BssDescription,
4883 D,
4884 val_ref,
4885 decoder,
4886 inner_offset,
4887 inner_depth
4888 )?;
4889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4890 {
4891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4892 }
4893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4895 }
4896 }
4897
4898 next_offset += envelope_size;
4899 _next_ordinal_to_read += 1;
4900 if next_offset >= end_offset {
4901 return Ok(());
4902 }
4903
4904 while _next_ordinal_to_read < 2 {
4906 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4907 _next_ordinal_to_read += 1;
4908 next_offset += envelope_size;
4909 }
4910
4911 let next_out_of_line = decoder.next_out_of_line();
4912 let handles_before = decoder.remaining_handles();
4913 if let Some((inlined, num_bytes, num_handles)) =
4914 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4915 {
4916 let member_inline_size =
4917 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4918 if inlined != (member_inline_size <= 4) {
4919 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4920 }
4921 let inner_offset;
4922 let mut inner_depth = depth.clone();
4923 if inlined {
4924 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4925 inner_offset = next_offset;
4926 } else {
4927 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4928 inner_depth.increment()?;
4929 }
4930 let val_ref =
4931 self.connect_failure_timeout.get_or_insert_with(|| fidl::new_empty!(u32, D));
4932 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934 {
4935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936 }
4937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939 }
4940 }
4941
4942 next_offset += envelope_size;
4943 _next_ordinal_to_read += 1;
4944 if next_offset >= end_offset {
4945 return Ok(());
4946 }
4947
4948 while _next_ordinal_to_read < 3 {
4950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951 _next_ordinal_to_read += 1;
4952 next_offset += envelope_size;
4953 }
4954
4955 let next_out_of_line = decoder.next_out_of_line();
4956 let handles_before = decoder.remaining_handles();
4957 if let Some((inlined, num_bytes, num_handles)) =
4958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959 {
4960 let member_inline_size =
4961 <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4962 if inlined != (member_inline_size <= 4) {
4963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4964 }
4965 let inner_offset;
4966 let mut inner_depth = depth.clone();
4967 if inlined {
4968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4969 inner_offset = next_offset;
4970 } else {
4971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4972 inner_depth.increment()?;
4973 }
4974 let val_ref =
4975 self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
4976 fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
4977 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4978 {
4979 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4980 }
4981 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4982 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4983 }
4984 }
4985
4986 next_offset += envelope_size;
4987 _next_ordinal_to_read += 1;
4988 if next_offset >= end_offset {
4989 return Ok(());
4990 }
4991
4992 while _next_ordinal_to_read < 4 {
4994 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4995 _next_ordinal_to_read += 1;
4996 next_offset += envelope_size;
4997 }
4998
4999 let next_out_of_line = decoder.next_out_of_line();
5000 let handles_before = decoder.remaining_handles();
5001 if let Some((inlined, num_bytes, num_handles)) =
5002 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5003 {
5004 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5005 if inlined != (member_inline_size <= 4) {
5006 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5007 }
5008 let inner_offset;
5009 let mut inner_depth = depth.clone();
5010 if inlined {
5011 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5012 inner_offset = next_offset;
5013 } else {
5014 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5015 inner_depth.increment()?;
5016 }
5017 let val_ref = self.sae_password.get_or_insert_with(|| {
5018 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5019 });
5020 fidl::decode!(
5021 fidl::encoding::UnboundedVector<u8>,
5022 D,
5023 val_ref,
5024 decoder,
5025 inner_offset,
5026 inner_depth
5027 )?;
5028 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5029 {
5030 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5031 }
5032 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5033 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5034 }
5035 }
5036
5037 next_offset += envelope_size;
5038 _next_ordinal_to_read += 1;
5039 if next_offset >= end_offset {
5040 return Ok(());
5041 }
5042
5043 while _next_ordinal_to_read < 5 {
5045 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5046 _next_ordinal_to_read += 1;
5047 next_offset += envelope_size;
5048 }
5049
5050 let next_out_of_line = decoder.next_out_of_line();
5051 let handles_before = decoder.remaining_handles();
5052 if let Some((inlined, num_bytes, num_handles)) =
5053 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5054 {
5055 let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5056 if inlined != (member_inline_size <= 4) {
5057 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5058 }
5059 let inner_offset;
5060 let mut inner_depth = depth.clone();
5061 if inlined {
5062 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5063 inner_offset = next_offset;
5064 } else {
5065 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5066 inner_depth.increment()?;
5067 }
5068 let val_ref = self.wep_key.get_or_insert_with(|| {
5069 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanKeyConfig, D)
5070 });
5071 fidl::decode!(
5072 fidl_fuchsia_wlan_common__common::WlanKeyConfig,
5073 D,
5074 val_ref,
5075 decoder,
5076 inner_offset,
5077 inner_depth
5078 )?;
5079 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5080 {
5081 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5082 }
5083 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5084 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5085 }
5086 }
5087
5088 next_offset += envelope_size;
5089 _next_ordinal_to_read += 1;
5090 if next_offset >= end_offset {
5091 return Ok(());
5092 }
5093
5094 while _next_ordinal_to_read < 6 {
5096 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5097 _next_ordinal_to_read += 1;
5098 next_offset += envelope_size;
5099 }
5100
5101 let next_out_of_line = decoder.next_out_of_line();
5102 let handles_before = decoder.remaining_handles();
5103 if let Some((inlined, num_bytes, num_handles)) =
5104 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5105 {
5106 let member_inline_size =
5107 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
5108 decoder.context,
5109 );
5110 if inlined != (member_inline_size <= 4) {
5111 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5112 }
5113 let inner_offset;
5114 let mut inner_depth = depth.clone();
5115 if inlined {
5116 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5117 inner_offset = next_offset;
5118 } else {
5119 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5120 inner_depth.increment()?;
5121 }
5122 let val_ref = self
5123 .security_ie
5124 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
5125 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
5126 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5127 {
5128 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5129 }
5130 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5131 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5132 }
5133 }
5134
5135 next_offset += envelope_size;
5136 _next_ordinal_to_read += 1;
5137 if next_offset >= end_offset {
5138 return Ok(());
5139 }
5140
5141 while _next_ordinal_to_read < 7 {
5143 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5144 _next_ordinal_to_read += 1;
5145 next_offset += envelope_size;
5146 }
5147
5148 let next_out_of_line = decoder.next_out_of_line();
5149 let handles_before = decoder.remaining_handles();
5150 if let Some((inlined, num_bytes, num_handles)) =
5151 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5152 {
5153 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5154 if inlined != (member_inline_size <= 4) {
5155 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5156 }
5157 let inner_offset;
5158 let mut inner_depth = depth.clone();
5159 if inlined {
5160 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5161 inner_offset = next_offset;
5162 } else {
5163 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5164 inner_depth.increment()?;
5165 }
5166 let val_ref = self.wep_key_desc.get_or_insert_with(|| {
5167 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D)
5168 });
5169 fidl::decode!(
5170 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
5171 D,
5172 val_ref,
5173 decoder,
5174 inner_offset,
5175 inner_depth
5176 )?;
5177 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5178 {
5179 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5180 }
5181 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5182 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5183 }
5184 }
5185
5186 next_offset += envelope_size;
5187
5188 while next_offset < end_offset {
5190 _next_ordinal_to_read += 1;
5191 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5192 next_offset += envelope_size;
5193 }
5194
5195 Ok(())
5196 }
5197 }
5198
5199 impl WlanFullmacImplDeauthRequest {
5200 #[inline(always)]
5201 fn max_ordinal_present(&self) -> u64 {
5202 if let Some(_) = self.reason_code {
5203 return 2;
5204 }
5205 if let Some(_) = self.peer_sta_address {
5206 return 1;
5207 }
5208 0
5209 }
5210 }
5211
5212 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDeauthRequest {
5213 type Borrowed<'a> = &'a Self;
5214 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5215 value
5216 }
5217 }
5218
5219 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDeauthRequest {
5220 type Owned = Self;
5221
5222 #[inline(always)]
5223 fn inline_align(_context: fidl::encoding::Context) -> usize {
5224 8
5225 }
5226
5227 #[inline(always)]
5228 fn inline_size(_context: fidl::encoding::Context) -> usize {
5229 16
5230 }
5231 }
5232
5233 unsafe impl<D: fidl::encoding::ResourceDialect>
5234 fidl::encoding::Encode<WlanFullmacImplDeauthRequest, D> for &WlanFullmacImplDeauthRequest
5235 {
5236 unsafe fn encode(
5237 self,
5238 encoder: &mut fidl::encoding::Encoder<'_, D>,
5239 offset: usize,
5240 mut depth: fidl::encoding::Depth,
5241 ) -> fidl::Result<()> {
5242 encoder.debug_check_bounds::<WlanFullmacImplDeauthRequest>(offset);
5243 let max_ordinal: u64 = self.max_ordinal_present();
5245 encoder.write_num(max_ordinal, offset);
5246 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5247 if max_ordinal == 0 {
5249 return Ok(());
5250 }
5251 depth.increment()?;
5252 let envelope_size = 8;
5253 let bytes_len = max_ordinal as usize * envelope_size;
5254 #[allow(unused_variables)]
5255 let offset = encoder.out_of_line_offset(bytes_len);
5256 let mut _prev_end_offset: usize = 0;
5257 if 1 > max_ordinal {
5258 return Ok(());
5259 }
5260
5261 let cur_offset: usize = (1 - 1) * envelope_size;
5264
5265 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5267
5268 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5273 self.peer_sta_address
5274 .as_ref()
5275 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5276 encoder,
5277 offset + cur_offset,
5278 depth,
5279 )?;
5280
5281 _prev_end_offset = cur_offset + envelope_size;
5282 if 2 > max_ordinal {
5283 return Ok(());
5284 }
5285
5286 let cur_offset: usize = (2 - 1) * envelope_size;
5289
5290 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5292
5293 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5298 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5299 encoder, offset + cur_offset, depth
5300 )?;
5301
5302 _prev_end_offset = cur_offset + envelope_size;
5303
5304 Ok(())
5305 }
5306 }
5307
5308 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5309 for WlanFullmacImplDeauthRequest
5310 {
5311 #[inline(always)]
5312 fn new_empty() -> Self {
5313 Self::default()
5314 }
5315
5316 unsafe fn decode(
5317 &mut self,
5318 decoder: &mut fidl::encoding::Decoder<'_, D>,
5319 offset: usize,
5320 mut depth: fidl::encoding::Depth,
5321 ) -> fidl::Result<()> {
5322 decoder.debug_check_bounds::<Self>(offset);
5323 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5324 None => return Err(fidl::Error::NotNullable),
5325 Some(len) => len,
5326 };
5327 if len == 0 {
5329 return Ok(());
5330 };
5331 depth.increment()?;
5332 let envelope_size = 8;
5333 let bytes_len = len * envelope_size;
5334 let offset = decoder.out_of_line_offset(bytes_len)?;
5335 let mut _next_ordinal_to_read = 0;
5337 let mut next_offset = offset;
5338 let end_offset = offset + bytes_len;
5339 _next_ordinal_to_read += 1;
5340 if next_offset >= end_offset {
5341 return Ok(());
5342 }
5343
5344 while _next_ordinal_to_read < 1 {
5346 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5347 _next_ordinal_to_read += 1;
5348 next_offset += envelope_size;
5349 }
5350
5351 let next_out_of_line = decoder.next_out_of_line();
5352 let handles_before = decoder.remaining_handles();
5353 if let Some((inlined, num_bytes, num_handles)) =
5354 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5355 {
5356 let member_inline_size =
5357 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5358 decoder.context,
5359 );
5360 if inlined != (member_inline_size <= 4) {
5361 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5362 }
5363 let inner_offset;
5364 let mut inner_depth = depth.clone();
5365 if inlined {
5366 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5367 inner_offset = next_offset;
5368 } else {
5369 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5370 inner_depth.increment()?;
5371 }
5372 let val_ref = self
5373 .peer_sta_address
5374 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5375 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5376 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5377 {
5378 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5379 }
5380 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5381 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5382 }
5383 }
5384
5385 next_offset += envelope_size;
5386 _next_ordinal_to_read += 1;
5387 if next_offset >= end_offset {
5388 return Ok(());
5389 }
5390
5391 while _next_ordinal_to_read < 2 {
5393 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5394 _next_ordinal_to_read += 1;
5395 next_offset += envelope_size;
5396 }
5397
5398 let next_out_of_line = decoder.next_out_of_line();
5399 let handles_before = decoder.remaining_handles();
5400 if let Some((inlined, num_bytes, num_handles)) =
5401 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5402 {
5403 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5404 if inlined != (member_inline_size <= 4) {
5405 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5406 }
5407 let inner_offset;
5408 let mut inner_depth = depth.clone();
5409 if inlined {
5410 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5411 inner_offset = next_offset;
5412 } else {
5413 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5414 inner_depth.increment()?;
5415 }
5416 let val_ref = self.reason_code.get_or_insert_with(|| {
5417 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5418 });
5419 fidl::decode!(
5420 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5421 D,
5422 val_ref,
5423 decoder,
5424 inner_offset,
5425 inner_depth
5426 )?;
5427 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5428 {
5429 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5430 }
5431 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5432 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5433 }
5434 }
5435
5436 next_offset += envelope_size;
5437
5438 while next_offset < end_offset {
5440 _next_ordinal_to_read += 1;
5441 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5442 next_offset += envelope_size;
5443 }
5444
5445 Ok(())
5446 }
5447 }
5448
5449 impl WlanFullmacImplDisassocRequest {
5450 #[inline(always)]
5451 fn max_ordinal_present(&self) -> u64 {
5452 if let Some(_) = self.reason_code {
5453 return 2;
5454 }
5455 if let Some(_) = self.peer_sta_address {
5456 return 1;
5457 }
5458 0
5459 }
5460 }
5461
5462 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDisassocRequest {
5463 type Borrowed<'a> = &'a Self;
5464 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5465 value
5466 }
5467 }
5468
5469 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDisassocRequest {
5470 type Owned = Self;
5471
5472 #[inline(always)]
5473 fn inline_align(_context: fidl::encoding::Context) -> usize {
5474 8
5475 }
5476
5477 #[inline(always)]
5478 fn inline_size(_context: fidl::encoding::Context) -> usize {
5479 16
5480 }
5481 }
5482
5483 unsafe impl<D: fidl::encoding::ResourceDialect>
5484 fidl::encoding::Encode<WlanFullmacImplDisassocRequest, D>
5485 for &WlanFullmacImplDisassocRequest
5486 {
5487 unsafe fn encode(
5488 self,
5489 encoder: &mut fidl::encoding::Encoder<'_, D>,
5490 offset: usize,
5491 mut depth: fidl::encoding::Depth,
5492 ) -> fidl::Result<()> {
5493 encoder.debug_check_bounds::<WlanFullmacImplDisassocRequest>(offset);
5494 let max_ordinal: u64 = self.max_ordinal_present();
5496 encoder.write_num(max_ordinal, offset);
5497 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5498 if max_ordinal == 0 {
5500 return Ok(());
5501 }
5502 depth.increment()?;
5503 let envelope_size = 8;
5504 let bytes_len = max_ordinal as usize * envelope_size;
5505 #[allow(unused_variables)]
5506 let offset = encoder.out_of_line_offset(bytes_len);
5507 let mut _prev_end_offset: usize = 0;
5508 if 1 > max_ordinal {
5509 return Ok(());
5510 }
5511
5512 let cur_offset: usize = (1 - 1) * envelope_size;
5515
5516 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5518
5519 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5524 self.peer_sta_address
5525 .as_ref()
5526 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5527 encoder,
5528 offset + cur_offset,
5529 depth,
5530 )?;
5531
5532 _prev_end_offset = cur_offset + envelope_size;
5533 if 2 > max_ordinal {
5534 return Ok(());
5535 }
5536
5537 let cur_offset: usize = (2 - 1) * envelope_size;
5540
5541 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5543
5544 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5549 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5550 encoder, offset + cur_offset, depth
5551 )?;
5552
5553 _prev_end_offset = cur_offset + envelope_size;
5554
5555 Ok(())
5556 }
5557 }
5558
5559 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5560 for WlanFullmacImplDisassocRequest
5561 {
5562 #[inline(always)]
5563 fn new_empty() -> Self {
5564 Self::default()
5565 }
5566
5567 unsafe fn decode(
5568 &mut self,
5569 decoder: &mut fidl::encoding::Decoder<'_, D>,
5570 offset: usize,
5571 mut depth: fidl::encoding::Depth,
5572 ) -> fidl::Result<()> {
5573 decoder.debug_check_bounds::<Self>(offset);
5574 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5575 None => return Err(fidl::Error::NotNullable),
5576 Some(len) => len,
5577 };
5578 if len == 0 {
5580 return Ok(());
5581 };
5582 depth.increment()?;
5583 let envelope_size = 8;
5584 let bytes_len = len * envelope_size;
5585 let offset = decoder.out_of_line_offset(bytes_len)?;
5586 let mut _next_ordinal_to_read = 0;
5588 let mut next_offset = offset;
5589 let end_offset = offset + bytes_len;
5590 _next_ordinal_to_read += 1;
5591 if next_offset >= end_offset {
5592 return Ok(());
5593 }
5594
5595 while _next_ordinal_to_read < 1 {
5597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5598 _next_ordinal_to_read += 1;
5599 next_offset += envelope_size;
5600 }
5601
5602 let next_out_of_line = decoder.next_out_of_line();
5603 let handles_before = decoder.remaining_handles();
5604 if let Some((inlined, num_bytes, num_handles)) =
5605 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5606 {
5607 let member_inline_size =
5608 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5609 decoder.context,
5610 );
5611 if inlined != (member_inline_size <= 4) {
5612 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5613 }
5614 let inner_offset;
5615 let mut inner_depth = depth.clone();
5616 if inlined {
5617 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5618 inner_offset = next_offset;
5619 } else {
5620 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5621 inner_depth.increment()?;
5622 }
5623 let val_ref = self
5624 .peer_sta_address
5625 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5626 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5627 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5628 {
5629 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5630 }
5631 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5632 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5633 }
5634 }
5635
5636 next_offset += envelope_size;
5637 _next_ordinal_to_read += 1;
5638 if next_offset >= end_offset {
5639 return Ok(());
5640 }
5641
5642 while _next_ordinal_to_read < 2 {
5644 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5645 _next_ordinal_to_read += 1;
5646 next_offset += envelope_size;
5647 }
5648
5649 let next_out_of_line = decoder.next_out_of_line();
5650 let handles_before = decoder.remaining_handles();
5651 if let Some((inlined, num_bytes, num_handles)) =
5652 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5653 {
5654 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5655 if inlined != (member_inline_size <= 4) {
5656 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5657 }
5658 let inner_offset;
5659 let mut inner_depth = depth.clone();
5660 if inlined {
5661 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5662 inner_offset = next_offset;
5663 } else {
5664 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5665 inner_depth.increment()?;
5666 }
5667 let val_ref = self.reason_code.get_or_insert_with(|| {
5668 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5669 });
5670 fidl::decode!(
5671 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5672 D,
5673 val_ref,
5674 decoder,
5675 inner_offset,
5676 inner_depth
5677 )?;
5678 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5679 {
5680 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5681 }
5682 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5683 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5684 }
5685 }
5686
5687 next_offset += envelope_size;
5688
5689 while next_offset < end_offset {
5691 _next_ordinal_to_read += 1;
5692 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5693 next_offset += envelope_size;
5694 }
5695
5696 Ok(())
5697 }
5698 }
5699
5700 impl WlanFullmacImplEapolTxRequest {
5701 #[inline(always)]
5702 fn max_ordinal_present(&self) -> u64 {
5703 if let Some(_) = self.data {
5704 return 3;
5705 }
5706 if let Some(_) = self.dst_addr {
5707 return 2;
5708 }
5709 if let Some(_) = self.src_addr {
5710 return 1;
5711 }
5712 0
5713 }
5714 }
5715
5716 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplEapolTxRequest {
5717 type Borrowed<'a> = &'a Self;
5718 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5719 value
5720 }
5721 }
5722
5723 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplEapolTxRequest {
5724 type Owned = Self;
5725
5726 #[inline(always)]
5727 fn inline_align(_context: fidl::encoding::Context) -> usize {
5728 8
5729 }
5730
5731 #[inline(always)]
5732 fn inline_size(_context: fidl::encoding::Context) -> usize {
5733 16
5734 }
5735 }
5736
5737 unsafe impl<D: fidl::encoding::ResourceDialect>
5738 fidl::encoding::Encode<WlanFullmacImplEapolTxRequest, D>
5739 for &WlanFullmacImplEapolTxRequest
5740 {
5741 unsafe fn encode(
5742 self,
5743 encoder: &mut fidl::encoding::Encoder<'_, D>,
5744 offset: usize,
5745 mut depth: fidl::encoding::Depth,
5746 ) -> fidl::Result<()> {
5747 encoder.debug_check_bounds::<WlanFullmacImplEapolTxRequest>(offset);
5748 let max_ordinal: u64 = self.max_ordinal_present();
5750 encoder.write_num(max_ordinal, offset);
5751 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5752 if max_ordinal == 0 {
5754 return Ok(());
5755 }
5756 depth.increment()?;
5757 let envelope_size = 8;
5758 let bytes_len = max_ordinal as usize * envelope_size;
5759 #[allow(unused_variables)]
5760 let offset = encoder.out_of_line_offset(bytes_len);
5761 let mut _prev_end_offset: usize = 0;
5762 if 1 > max_ordinal {
5763 return Ok(());
5764 }
5765
5766 let cur_offset: usize = (1 - 1) * envelope_size;
5769
5770 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5772
5773 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5778 self.src_addr
5779 .as_ref()
5780 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5781 encoder,
5782 offset + cur_offset,
5783 depth,
5784 )?;
5785
5786 _prev_end_offset = cur_offset + envelope_size;
5787 if 2 > max_ordinal {
5788 return Ok(());
5789 }
5790
5791 let cur_offset: usize = (2 - 1) * envelope_size;
5794
5795 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5797
5798 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5803 self.dst_addr
5804 .as_ref()
5805 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5806 encoder,
5807 offset + cur_offset,
5808 depth,
5809 )?;
5810
5811 _prev_end_offset = cur_offset + envelope_size;
5812 if 3 > max_ordinal {
5813 return Ok(());
5814 }
5815
5816 let cur_offset: usize = (3 - 1) * envelope_size;
5819
5820 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5822
5823 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
5828 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
5829 encoder, offset + cur_offset, depth
5830 )?;
5831
5832 _prev_end_offset = cur_offset + envelope_size;
5833
5834 Ok(())
5835 }
5836 }
5837
5838 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5839 for WlanFullmacImplEapolTxRequest
5840 {
5841 #[inline(always)]
5842 fn new_empty() -> Self {
5843 Self::default()
5844 }
5845
5846 unsafe fn decode(
5847 &mut self,
5848 decoder: &mut fidl::encoding::Decoder<'_, D>,
5849 offset: usize,
5850 mut depth: fidl::encoding::Depth,
5851 ) -> fidl::Result<()> {
5852 decoder.debug_check_bounds::<Self>(offset);
5853 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5854 None => return Err(fidl::Error::NotNullable),
5855 Some(len) => len,
5856 };
5857 if len == 0 {
5859 return Ok(());
5860 };
5861 depth.increment()?;
5862 let envelope_size = 8;
5863 let bytes_len = len * envelope_size;
5864 let offset = decoder.out_of_line_offset(bytes_len)?;
5865 let mut _next_ordinal_to_read = 0;
5867 let mut next_offset = offset;
5868 let end_offset = offset + bytes_len;
5869 _next_ordinal_to_read += 1;
5870 if next_offset >= end_offset {
5871 return Ok(());
5872 }
5873
5874 while _next_ordinal_to_read < 1 {
5876 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5877 _next_ordinal_to_read += 1;
5878 next_offset += envelope_size;
5879 }
5880
5881 let next_out_of_line = decoder.next_out_of_line();
5882 let handles_before = decoder.remaining_handles();
5883 if let Some((inlined, num_bytes, num_handles)) =
5884 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5885 {
5886 let member_inline_size =
5887 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5888 decoder.context,
5889 );
5890 if inlined != (member_inline_size <= 4) {
5891 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5892 }
5893 let inner_offset;
5894 let mut inner_depth = depth.clone();
5895 if inlined {
5896 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5897 inner_offset = next_offset;
5898 } else {
5899 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5900 inner_depth.increment()?;
5901 }
5902 let val_ref = self
5903 .src_addr
5904 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5905 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5906 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5907 {
5908 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5909 }
5910 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5911 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5912 }
5913 }
5914
5915 next_offset += envelope_size;
5916 _next_ordinal_to_read += 1;
5917 if next_offset >= end_offset {
5918 return Ok(());
5919 }
5920
5921 while _next_ordinal_to_read < 2 {
5923 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5924 _next_ordinal_to_read += 1;
5925 next_offset += envelope_size;
5926 }
5927
5928 let next_out_of_line = decoder.next_out_of_line();
5929 let handles_before = decoder.remaining_handles();
5930 if let Some((inlined, num_bytes, num_handles)) =
5931 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5932 {
5933 let member_inline_size =
5934 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5935 decoder.context,
5936 );
5937 if inlined != (member_inline_size <= 4) {
5938 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5939 }
5940 let inner_offset;
5941 let mut inner_depth = depth.clone();
5942 if inlined {
5943 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5944 inner_offset = next_offset;
5945 } else {
5946 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5947 inner_depth.increment()?;
5948 }
5949 let val_ref = self
5950 .dst_addr
5951 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5952 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5953 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5954 {
5955 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5956 }
5957 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5958 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5959 }
5960 }
5961
5962 next_offset += envelope_size;
5963 _next_ordinal_to_read += 1;
5964 if next_offset >= end_offset {
5965 return Ok(());
5966 }
5967
5968 while _next_ordinal_to_read < 3 {
5970 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5971 _next_ordinal_to_read += 1;
5972 next_offset += envelope_size;
5973 }
5974
5975 let next_out_of_line = decoder.next_out_of_line();
5976 let handles_before = decoder.remaining_handles();
5977 if let Some((inlined, num_bytes, num_handles)) =
5978 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5979 {
5980 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5981 if inlined != (member_inline_size <= 4) {
5982 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5983 }
5984 let inner_offset;
5985 let mut inner_depth = depth.clone();
5986 if inlined {
5987 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5988 inner_offset = next_offset;
5989 } else {
5990 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5991 inner_depth.increment()?;
5992 }
5993 let val_ref = self.data.get_or_insert_with(|| {
5994 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5995 });
5996 fidl::decode!(
5997 fidl::encoding::UnboundedVector<u8>,
5998 D,
5999 val_ref,
6000 decoder,
6001 inner_offset,
6002 inner_depth
6003 )?;
6004 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6005 {
6006 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6007 }
6008 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6009 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6010 }
6011 }
6012
6013 next_offset += envelope_size;
6014
6015 while next_offset < end_offset {
6017 _next_ordinal_to_read += 1;
6018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6019 next_offset += envelope_size;
6020 }
6021
6022 Ok(())
6023 }
6024 }
6025
6026 impl WlanFullmacImplIfcAssocIndRequest {
6027 #[inline(always)]
6028 fn max_ordinal_present(&self) -> u64 {
6029 if let Some(_) = self.vendor_ie {
6030 return 5;
6031 }
6032 if let Some(_) = self.rsne {
6033 return 4;
6034 }
6035 if let Some(_) = self.ssid {
6036 return 3;
6037 }
6038 if let Some(_) = self.listen_interval {
6039 return 2;
6040 }
6041 if let Some(_) = self.peer_sta_address {
6042 return 1;
6043 }
6044 0
6045 }
6046 }
6047
6048 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAssocIndRequest {
6049 type Borrowed<'a> = &'a Self;
6050 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6051 value
6052 }
6053 }
6054
6055 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAssocIndRequest {
6056 type Owned = Self;
6057
6058 #[inline(always)]
6059 fn inline_align(_context: fidl::encoding::Context) -> usize {
6060 8
6061 }
6062
6063 #[inline(always)]
6064 fn inline_size(_context: fidl::encoding::Context) -> usize {
6065 16
6066 }
6067 }
6068
6069 unsafe impl<D: fidl::encoding::ResourceDialect>
6070 fidl::encoding::Encode<WlanFullmacImplIfcAssocIndRequest, D>
6071 for &WlanFullmacImplIfcAssocIndRequest
6072 {
6073 unsafe fn encode(
6074 self,
6075 encoder: &mut fidl::encoding::Encoder<'_, D>,
6076 offset: usize,
6077 mut depth: fidl::encoding::Depth,
6078 ) -> fidl::Result<()> {
6079 encoder.debug_check_bounds::<WlanFullmacImplIfcAssocIndRequest>(offset);
6080 let max_ordinal: u64 = self.max_ordinal_present();
6082 encoder.write_num(max_ordinal, offset);
6083 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6084 if max_ordinal == 0 {
6086 return Ok(());
6087 }
6088 depth.increment()?;
6089 let envelope_size = 8;
6090 let bytes_len = max_ordinal as usize * envelope_size;
6091 #[allow(unused_variables)]
6092 let offset = encoder.out_of_line_offset(bytes_len);
6093 let mut _prev_end_offset: usize = 0;
6094 if 1 > max_ordinal {
6095 return Ok(());
6096 }
6097
6098 let cur_offset: usize = (1 - 1) * envelope_size;
6101
6102 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6104
6105 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6110 self.peer_sta_address
6111 .as_ref()
6112 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6113 encoder,
6114 offset + cur_offset,
6115 depth,
6116 )?;
6117
6118 _prev_end_offset = cur_offset + envelope_size;
6119 if 2 > max_ordinal {
6120 return Ok(());
6121 }
6122
6123 let cur_offset: usize = (2 - 1) * envelope_size;
6126
6127 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6129
6130 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6135 self.listen_interval.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6136 encoder,
6137 offset + cur_offset,
6138 depth,
6139 )?;
6140
6141 _prev_end_offset = cur_offset + envelope_size;
6142 if 3 > max_ordinal {
6143 return Ok(());
6144 }
6145
6146 let cur_offset: usize = (3 - 1) * envelope_size;
6149
6150 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6152
6153 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
6158 self.ssid.as_ref().map(
6159 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
6160 ),
6161 encoder,
6162 offset + cur_offset,
6163 depth,
6164 )?;
6165
6166 _prev_end_offset = cur_offset + envelope_size;
6167 if 4 > max_ordinal {
6168 return Ok(());
6169 }
6170
6171 let cur_offset: usize = (4 - 1) * envelope_size;
6174
6175 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6177
6178 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
6183 self.rsne.as_ref().map(
6184 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
6185 ),
6186 encoder,
6187 offset + cur_offset,
6188 depth,
6189 )?;
6190
6191 _prev_end_offset = cur_offset + envelope_size;
6192 if 5 > max_ordinal {
6193 return Ok(());
6194 }
6195
6196 let cur_offset: usize = (5 - 1) * envelope_size;
6199
6200 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6202
6203 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
6208 self.vendor_ie.as_ref().map(
6209 <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
6210 ),
6211 encoder,
6212 offset + cur_offset,
6213 depth,
6214 )?;
6215
6216 _prev_end_offset = cur_offset + envelope_size;
6217
6218 Ok(())
6219 }
6220 }
6221
6222 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6223 for WlanFullmacImplIfcAssocIndRequest
6224 {
6225 #[inline(always)]
6226 fn new_empty() -> Self {
6227 Self::default()
6228 }
6229
6230 unsafe fn decode(
6231 &mut self,
6232 decoder: &mut fidl::encoding::Decoder<'_, D>,
6233 offset: usize,
6234 mut depth: fidl::encoding::Depth,
6235 ) -> fidl::Result<()> {
6236 decoder.debug_check_bounds::<Self>(offset);
6237 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6238 None => return Err(fidl::Error::NotNullable),
6239 Some(len) => len,
6240 };
6241 if len == 0 {
6243 return Ok(());
6244 };
6245 depth.increment()?;
6246 let envelope_size = 8;
6247 let bytes_len = len * envelope_size;
6248 let offset = decoder.out_of_line_offset(bytes_len)?;
6249 let mut _next_ordinal_to_read = 0;
6251 let mut next_offset = offset;
6252 let end_offset = offset + bytes_len;
6253 _next_ordinal_to_read += 1;
6254 if next_offset >= end_offset {
6255 return Ok(());
6256 }
6257
6258 while _next_ordinal_to_read < 1 {
6260 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6261 _next_ordinal_to_read += 1;
6262 next_offset += envelope_size;
6263 }
6264
6265 let next_out_of_line = decoder.next_out_of_line();
6266 let handles_before = decoder.remaining_handles();
6267 if let Some((inlined, num_bytes, num_handles)) =
6268 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6269 {
6270 let member_inline_size =
6271 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6272 decoder.context,
6273 );
6274 if inlined != (member_inline_size <= 4) {
6275 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6276 }
6277 let inner_offset;
6278 let mut inner_depth = depth.clone();
6279 if inlined {
6280 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6281 inner_offset = next_offset;
6282 } else {
6283 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6284 inner_depth.increment()?;
6285 }
6286 let val_ref = self
6287 .peer_sta_address
6288 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6289 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6290 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6291 {
6292 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6293 }
6294 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6295 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6296 }
6297 }
6298
6299 next_offset += envelope_size;
6300 _next_ordinal_to_read += 1;
6301 if next_offset >= end_offset {
6302 return Ok(());
6303 }
6304
6305 while _next_ordinal_to_read < 2 {
6307 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6308 _next_ordinal_to_read += 1;
6309 next_offset += envelope_size;
6310 }
6311
6312 let next_out_of_line = decoder.next_out_of_line();
6313 let handles_before = decoder.remaining_handles();
6314 if let Some((inlined, num_bytes, num_handles)) =
6315 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6316 {
6317 let member_inline_size =
6318 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6319 if inlined != (member_inline_size <= 4) {
6320 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6321 }
6322 let inner_offset;
6323 let mut inner_depth = depth.clone();
6324 if inlined {
6325 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6326 inner_offset = next_offset;
6327 } else {
6328 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6329 inner_depth.increment()?;
6330 }
6331 let val_ref = self.listen_interval.get_or_insert_with(|| fidl::new_empty!(u16, D));
6332 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6333 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6334 {
6335 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6336 }
6337 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6338 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6339 }
6340 }
6341
6342 next_offset += envelope_size;
6343 _next_ordinal_to_read += 1;
6344 if next_offset >= end_offset {
6345 return Ok(());
6346 }
6347
6348 while _next_ordinal_to_read < 3 {
6350 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6351 _next_ordinal_to_read += 1;
6352 next_offset += envelope_size;
6353 }
6354
6355 let next_out_of_line = decoder.next_out_of_line();
6356 let handles_before = decoder.remaining_handles();
6357 if let Some((inlined, num_bytes, num_handles)) =
6358 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6359 {
6360 let member_inline_size =
6361 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6362 decoder.context,
6363 );
6364 if inlined != (member_inline_size <= 4) {
6365 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6366 }
6367 let inner_offset;
6368 let mut inner_depth = depth.clone();
6369 if inlined {
6370 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6371 inner_offset = next_offset;
6372 } else {
6373 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6374 inner_depth.increment()?;
6375 }
6376 let val_ref = self
6377 .ssid
6378 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
6379 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6381 {
6382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6383 }
6384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6386 }
6387 }
6388
6389 next_offset += envelope_size;
6390 _next_ordinal_to_read += 1;
6391 if next_offset >= end_offset {
6392 return Ok(());
6393 }
6394
6395 while _next_ordinal_to_read < 4 {
6397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6398 _next_ordinal_to_read += 1;
6399 next_offset += envelope_size;
6400 }
6401
6402 let next_out_of_line = decoder.next_out_of_line();
6403 let handles_before = decoder.remaining_handles();
6404 if let Some((inlined, num_bytes, num_handles)) =
6405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6406 {
6407 let member_inline_size =
6408 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
6409 decoder.context,
6410 );
6411 if inlined != (member_inline_size <= 4) {
6412 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6413 }
6414 let inner_offset;
6415 let mut inner_depth = depth.clone();
6416 if inlined {
6417 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6418 inner_offset = next_offset;
6419 } else {
6420 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6421 inner_depth.increment()?;
6422 }
6423 let val_ref = self
6424 .rsne
6425 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
6426 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
6427 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6428 {
6429 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6430 }
6431 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6432 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6433 }
6434 }
6435
6436 next_offset += envelope_size;
6437 _next_ordinal_to_read += 1;
6438 if next_offset >= end_offset {
6439 return Ok(());
6440 }
6441
6442 while _next_ordinal_to_read < 5 {
6444 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6445 _next_ordinal_to_read += 1;
6446 next_offset += envelope_size;
6447 }
6448
6449 let next_out_of_line = decoder.next_out_of_line();
6450 let handles_before = decoder.remaining_handles();
6451 if let Some((inlined, num_bytes, num_handles)) =
6452 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6453 {
6454 let member_inline_size =
6455 <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
6456 decoder.context,
6457 );
6458 if inlined != (member_inline_size <= 4) {
6459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6460 }
6461 let inner_offset;
6462 let mut inner_depth = depth.clone();
6463 if inlined {
6464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6465 inner_offset = next_offset;
6466 } else {
6467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6468 inner_depth.increment()?;
6469 }
6470 let val_ref = self
6471 .vendor_ie
6472 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
6473 fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
6474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6475 {
6476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6477 }
6478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6480 }
6481 }
6482
6483 next_offset += envelope_size;
6484
6485 while next_offset < end_offset {
6487 _next_ordinal_to_read += 1;
6488 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6489 next_offset += envelope_size;
6490 }
6491
6492 Ok(())
6493 }
6494 }
6495
6496 impl WlanFullmacImplIfcAuthIndRequest {
6497 #[inline(always)]
6498 fn max_ordinal_present(&self) -> u64 {
6499 if let Some(_) = self.auth_type {
6500 return 2;
6501 }
6502 if let Some(_) = self.peer_sta_address {
6503 return 1;
6504 }
6505 0
6506 }
6507 }
6508
6509 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAuthIndRequest {
6510 type Borrowed<'a> = &'a Self;
6511 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6512 value
6513 }
6514 }
6515
6516 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAuthIndRequest {
6517 type Owned = Self;
6518
6519 #[inline(always)]
6520 fn inline_align(_context: fidl::encoding::Context) -> usize {
6521 8
6522 }
6523
6524 #[inline(always)]
6525 fn inline_size(_context: fidl::encoding::Context) -> usize {
6526 16
6527 }
6528 }
6529
6530 unsafe impl<D: fidl::encoding::ResourceDialect>
6531 fidl::encoding::Encode<WlanFullmacImplIfcAuthIndRequest, D>
6532 for &WlanFullmacImplIfcAuthIndRequest
6533 {
6534 unsafe fn encode(
6535 self,
6536 encoder: &mut fidl::encoding::Encoder<'_, D>,
6537 offset: usize,
6538 mut depth: fidl::encoding::Depth,
6539 ) -> fidl::Result<()> {
6540 encoder.debug_check_bounds::<WlanFullmacImplIfcAuthIndRequest>(offset);
6541 let max_ordinal: u64 = self.max_ordinal_present();
6543 encoder.write_num(max_ordinal, offset);
6544 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6545 if max_ordinal == 0 {
6547 return Ok(());
6548 }
6549 depth.increment()?;
6550 let envelope_size = 8;
6551 let bytes_len = max_ordinal as usize * envelope_size;
6552 #[allow(unused_variables)]
6553 let offset = encoder.out_of_line_offset(bytes_len);
6554 let mut _prev_end_offset: usize = 0;
6555 if 1 > max_ordinal {
6556 return Ok(());
6557 }
6558
6559 let cur_offset: usize = (1 - 1) * envelope_size;
6562
6563 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6565
6566 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6571 self.peer_sta_address
6572 .as_ref()
6573 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6574 encoder,
6575 offset + cur_offset,
6576 depth,
6577 )?;
6578
6579 _prev_end_offset = cur_offset + envelope_size;
6580 if 2 > max_ordinal {
6581 return Ok(());
6582 }
6583
6584 let cur_offset: usize = (2 - 1) * envelope_size;
6587
6588 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6590
6591 fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
6596 self.auth_type
6597 .as_ref()
6598 .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
6599 encoder,
6600 offset + cur_offset,
6601 depth,
6602 )?;
6603
6604 _prev_end_offset = cur_offset + envelope_size;
6605
6606 Ok(())
6607 }
6608 }
6609
6610 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6611 for WlanFullmacImplIfcAuthIndRequest
6612 {
6613 #[inline(always)]
6614 fn new_empty() -> Self {
6615 Self::default()
6616 }
6617
6618 unsafe fn decode(
6619 &mut self,
6620 decoder: &mut fidl::encoding::Decoder<'_, D>,
6621 offset: usize,
6622 mut depth: fidl::encoding::Depth,
6623 ) -> fidl::Result<()> {
6624 decoder.debug_check_bounds::<Self>(offset);
6625 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6626 None => return Err(fidl::Error::NotNullable),
6627 Some(len) => len,
6628 };
6629 if len == 0 {
6631 return Ok(());
6632 };
6633 depth.increment()?;
6634 let envelope_size = 8;
6635 let bytes_len = len * envelope_size;
6636 let offset = decoder.out_of_line_offset(bytes_len)?;
6637 let mut _next_ordinal_to_read = 0;
6639 let mut next_offset = offset;
6640 let end_offset = offset + bytes_len;
6641 _next_ordinal_to_read += 1;
6642 if next_offset >= end_offset {
6643 return Ok(());
6644 }
6645
6646 while _next_ordinal_to_read < 1 {
6648 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6649 _next_ordinal_to_read += 1;
6650 next_offset += envelope_size;
6651 }
6652
6653 let next_out_of_line = decoder.next_out_of_line();
6654 let handles_before = decoder.remaining_handles();
6655 if let Some((inlined, num_bytes, num_handles)) =
6656 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6657 {
6658 let member_inline_size =
6659 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6660 decoder.context,
6661 );
6662 if inlined != (member_inline_size <= 4) {
6663 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6664 }
6665 let inner_offset;
6666 let mut inner_depth = depth.clone();
6667 if inlined {
6668 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6669 inner_offset = next_offset;
6670 } else {
6671 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6672 inner_depth.increment()?;
6673 }
6674 let val_ref = self
6675 .peer_sta_address
6676 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6677 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6678 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6679 {
6680 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6681 }
6682 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6683 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6684 }
6685 }
6686
6687 next_offset += envelope_size;
6688 _next_ordinal_to_read += 1;
6689 if next_offset >= end_offset {
6690 return Ok(());
6691 }
6692
6693 while _next_ordinal_to_read < 2 {
6695 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6696 _next_ordinal_to_read += 1;
6697 next_offset += envelope_size;
6698 }
6699
6700 let next_out_of_line = decoder.next_out_of_line();
6701 let handles_before = decoder.remaining_handles();
6702 if let Some((inlined, num_bytes, num_handles)) =
6703 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6704 {
6705 let member_inline_size =
6706 <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6707 if inlined != (member_inline_size <= 4) {
6708 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6709 }
6710 let inner_offset;
6711 let mut inner_depth = depth.clone();
6712 if inlined {
6713 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6714 inner_offset = next_offset;
6715 } else {
6716 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6717 inner_depth.increment()?;
6718 }
6719 let val_ref =
6720 self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
6721 fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
6722 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6723 {
6724 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6725 }
6726 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6727 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6728 }
6729 }
6730
6731 next_offset += envelope_size;
6732
6733 while next_offset < end_offset {
6735 _next_ordinal_to_read += 1;
6736 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6737 next_offset += envelope_size;
6738 }
6739
6740 Ok(())
6741 }
6742 }
6743
6744 impl WlanFullmacImplIfcConnectConfRequest {
6745 #[inline(always)]
6746 fn max_ordinal_present(&self) -> u64 {
6747 if let Some(_) = self.association_ies {
6748 return 4;
6749 }
6750 if let Some(_) = self.association_id {
6751 return 3;
6752 }
6753 if let Some(_) = self.result_code {
6754 return 2;
6755 }
6756 if let Some(_) = self.peer_sta_address {
6757 return 1;
6758 }
6759 0
6760 }
6761 }
6762
6763 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcConnectConfRequest {
6764 type Borrowed<'a> = &'a Self;
6765 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6766 value
6767 }
6768 }
6769
6770 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcConnectConfRequest {
6771 type Owned = Self;
6772
6773 #[inline(always)]
6774 fn inline_align(_context: fidl::encoding::Context) -> usize {
6775 8
6776 }
6777
6778 #[inline(always)]
6779 fn inline_size(_context: fidl::encoding::Context) -> usize {
6780 16
6781 }
6782 }
6783
6784 unsafe impl<D: fidl::encoding::ResourceDialect>
6785 fidl::encoding::Encode<WlanFullmacImplIfcConnectConfRequest, D>
6786 for &WlanFullmacImplIfcConnectConfRequest
6787 {
6788 unsafe fn encode(
6789 self,
6790 encoder: &mut fidl::encoding::Encoder<'_, D>,
6791 offset: usize,
6792 mut depth: fidl::encoding::Depth,
6793 ) -> fidl::Result<()> {
6794 encoder.debug_check_bounds::<WlanFullmacImplIfcConnectConfRequest>(offset);
6795 let max_ordinal: u64 = self.max_ordinal_present();
6797 encoder.write_num(max_ordinal, offset);
6798 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6799 if max_ordinal == 0 {
6801 return Ok(());
6802 }
6803 depth.increment()?;
6804 let envelope_size = 8;
6805 let bytes_len = max_ordinal as usize * envelope_size;
6806 #[allow(unused_variables)]
6807 let offset = encoder.out_of_line_offset(bytes_len);
6808 let mut _prev_end_offset: usize = 0;
6809 if 1 > max_ordinal {
6810 return Ok(());
6811 }
6812
6813 let cur_offset: usize = (1 - 1) * envelope_size;
6816
6817 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6819
6820 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6825 self.peer_sta_address
6826 .as_ref()
6827 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6828 encoder,
6829 offset + cur_offset,
6830 depth,
6831 )?;
6832
6833 _prev_end_offset = cur_offset + envelope_size;
6834 if 2 > max_ordinal {
6835 return Ok(());
6836 }
6837
6838 let cur_offset: usize = (2 - 1) * envelope_size;
6841
6842 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6844
6845 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
6850 self.result_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
6851 encoder, offset + cur_offset, depth
6852 )?;
6853
6854 _prev_end_offset = cur_offset + envelope_size;
6855 if 3 > max_ordinal {
6856 return Ok(());
6857 }
6858
6859 let cur_offset: usize = (3 - 1) * envelope_size;
6862
6863 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6865
6866 fidl::encoding::encode_in_envelope_optional::<u16, D>(
6871 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6872 encoder,
6873 offset + cur_offset,
6874 depth,
6875 )?;
6876
6877 _prev_end_offset = cur_offset + envelope_size;
6878 if 4 > max_ordinal {
6879 return Ok(());
6880 }
6881
6882 let cur_offset: usize = (4 - 1) * envelope_size;
6885
6886 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6888
6889 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6894 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6895 encoder, offset + cur_offset, depth
6896 )?;
6897
6898 _prev_end_offset = cur_offset + envelope_size;
6899
6900 Ok(())
6901 }
6902 }
6903
6904 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6905 for WlanFullmacImplIfcConnectConfRequest
6906 {
6907 #[inline(always)]
6908 fn new_empty() -> Self {
6909 Self::default()
6910 }
6911
6912 unsafe fn decode(
6913 &mut self,
6914 decoder: &mut fidl::encoding::Decoder<'_, D>,
6915 offset: usize,
6916 mut depth: fidl::encoding::Depth,
6917 ) -> fidl::Result<()> {
6918 decoder.debug_check_bounds::<Self>(offset);
6919 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6920 None => return Err(fidl::Error::NotNullable),
6921 Some(len) => len,
6922 };
6923 if len == 0 {
6925 return Ok(());
6926 };
6927 depth.increment()?;
6928 let envelope_size = 8;
6929 let bytes_len = len * envelope_size;
6930 let offset = decoder.out_of_line_offset(bytes_len)?;
6931 let mut _next_ordinal_to_read = 0;
6933 let mut next_offset = offset;
6934 let end_offset = offset + bytes_len;
6935 _next_ordinal_to_read += 1;
6936 if next_offset >= end_offset {
6937 return Ok(());
6938 }
6939
6940 while _next_ordinal_to_read < 1 {
6942 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6943 _next_ordinal_to_read += 1;
6944 next_offset += envelope_size;
6945 }
6946
6947 let next_out_of_line = decoder.next_out_of_line();
6948 let handles_before = decoder.remaining_handles();
6949 if let Some((inlined, num_bytes, num_handles)) =
6950 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6951 {
6952 let member_inline_size =
6953 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6954 decoder.context,
6955 );
6956 if inlined != (member_inline_size <= 4) {
6957 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6958 }
6959 let inner_offset;
6960 let mut inner_depth = depth.clone();
6961 if inlined {
6962 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6963 inner_offset = next_offset;
6964 } else {
6965 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6966 inner_depth.increment()?;
6967 }
6968 let val_ref = self
6969 .peer_sta_address
6970 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6971 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6972 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6973 {
6974 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6975 }
6976 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6977 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6978 }
6979 }
6980
6981 next_offset += envelope_size;
6982 _next_ordinal_to_read += 1;
6983 if next_offset >= end_offset {
6984 return Ok(());
6985 }
6986
6987 while _next_ordinal_to_read < 2 {
6989 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6990 _next_ordinal_to_read += 1;
6991 next_offset += envelope_size;
6992 }
6993
6994 let next_out_of_line = decoder.next_out_of_line();
6995 let handles_before = decoder.remaining_handles();
6996 if let Some((inlined, num_bytes, num_handles)) =
6997 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6998 {
6999 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7000 if inlined != (member_inline_size <= 4) {
7001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7002 }
7003 let inner_offset;
7004 let mut inner_depth = depth.clone();
7005 if inlined {
7006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7007 inner_offset = next_offset;
7008 } else {
7009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7010 inner_depth.increment()?;
7011 }
7012 let val_ref = self.result_code.get_or_insert_with(|| {
7013 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
7014 });
7015 fidl::decode!(
7016 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
7017 D,
7018 val_ref,
7019 decoder,
7020 inner_offset,
7021 inner_depth
7022 )?;
7023 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7024 {
7025 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7026 }
7027 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7028 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7029 }
7030 }
7031
7032 next_offset += envelope_size;
7033 _next_ordinal_to_read += 1;
7034 if next_offset >= end_offset {
7035 return Ok(());
7036 }
7037
7038 while _next_ordinal_to_read < 3 {
7040 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7041 _next_ordinal_to_read += 1;
7042 next_offset += envelope_size;
7043 }
7044
7045 let next_out_of_line = decoder.next_out_of_line();
7046 let handles_before = decoder.remaining_handles();
7047 if let Some((inlined, num_bytes, num_handles)) =
7048 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7049 {
7050 let member_inline_size =
7051 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7052 if inlined != (member_inline_size <= 4) {
7053 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7054 }
7055 let inner_offset;
7056 let mut inner_depth = depth.clone();
7057 if inlined {
7058 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7059 inner_offset = next_offset;
7060 } else {
7061 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7062 inner_depth.increment()?;
7063 }
7064 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
7065 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
7066 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7067 {
7068 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7069 }
7070 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7071 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7072 }
7073 }
7074
7075 next_offset += envelope_size;
7076 _next_ordinal_to_read += 1;
7077 if next_offset >= end_offset {
7078 return Ok(());
7079 }
7080
7081 while _next_ordinal_to_read < 4 {
7083 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7084 _next_ordinal_to_read += 1;
7085 next_offset += envelope_size;
7086 }
7087
7088 let next_out_of_line = decoder.next_out_of_line();
7089 let handles_before = decoder.remaining_handles();
7090 if let Some((inlined, num_bytes, num_handles)) =
7091 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7092 {
7093 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7094 if inlined != (member_inline_size <= 4) {
7095 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7096 }
7097 let inner_offset;
7098 let mut inner_depth = depth.clone();
7099 if inlined {
7100 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7101 inner_offset = next_offset;
7102 } else {
7103 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7104 inner_depth.increment()?;
7105 }
7106 let val_ref = self.association_ies.get_or_insert_with(|| {
7107 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
7108 });
7109 fidl::decode!(
7110 fidl::encoding::UnboundedVector<u8>,
7111 D,
7112 val_ref,
7113 decoder,
7114 inner_offset,
7115 inner_depth
7116 )?;
7117 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7118 {
7119 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7120 }
7121 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7122 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7123 }
7124 }
7125
7126 next_offset += envelope_size;
7127
7128 while next_offset < end_offset {
7130 _next_ordinal_to_read += 1;
7131 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7132 next_offset += envelope_size;
7133 }
7134
7135 Ok(())
7136 }
7137 }
7138
7139 impl WlanFullmacImplIfcDeauthConfRequest {
7140 #[inline(always)]
7141 fn max_ordinal_present(&self) -> u64 {
7142 if let Some(_) = self.peer_sta_address {
7143 return 1;
7144 }
7145 0
7146 }
7147 }
7148
7149 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7150 type Borrowed<'a> = &'a Self;
7151 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7152 value
7153 }
7154 }
7155
7156 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7157 type Owned = Self;
7158
7159 #[inline(always)]
7160 fn inline_align(_context: fidl::encoding::Context) -> usize {
7161 8
7162 }
7163
7164 #[inline(always)]
7165 fn inline_size(_context: fidl::encoding::Context) -> usize {
7166 16
7167 }
7168 }
7169
7170 unsafe impl<D: fidl::encoding::ResourceDialect>
7171 fidl::encoding::Encode<WlanFullmacImplIfcDeauthConfRequest, D>
7172 for &WlanFullmacImplIfcDeauthConfRequest
7173 {
7174 unsafe fn encode(
7175 self,
7176 encoder: &mut fidl::encoding::Encoder<'_, D>,
7177 offset: usize,
7178 mut depth: fidl::encoding::Depth,
7179 ) -> fidl::Result<()> {
7180 encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthConfRequest>(offset);
7181 let max_ordinal: u64 = self.max_ordinal_present();
7183 encoder.write_num(max_ordinal, offset);
7184 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7185 if max_ordinal == 0 {
7187 return Ok(());
7188 }
7189 depth.increment()?;
7190 let envelope_size = 8;
7191 let bytes_len = max_ordinal as usize * envelope_size;
7192 #[allow(unused_variables)]
7193 let offset = encoder.out_of_line_offset(bytes_len);
7194 let mut _prev_end_offset: usize = 0;
7195 if 1 > max_ordinal {
7196 return Ok(());
7197 }
7198
7199 let cur_offset: usize = (1 - 1) * envelope_size;
7202
7203 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7205
7206 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7211 self.peer_sta_address
7212 .as_ref()
7213 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7214 encoder,
7215 offset + cur_offset,
7216 depth,
7217 )?;
7218
7219 _prev_end_offset = cur_offset + envelope_size;
7220
7221 Ok(())
7222 }
7223 }
7224
7225 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7226 for WlanFullmacImplIfcDeauthConfRequest
7227 {
7228 #[inline(always)]
7229 fn new_empty() -> Self {
7230 Self::default()
7231 }
7232
7233 unsafe fn decode(
7234 &mut self,
7235 decoder: &mut fidl::encoding::Decoder<'_, D>,
7236 offset: usize,
7237 mut depth: fidl::encoding::Depth,
7238 ) -> fidl::Result<()> {
7239 decoder.debug_check_bounds::<Self>(offset);
7240 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7241 None => return Err(fidl::Error::NotNullable),
7242 Some(len) => len,
7243 };
7244 if len == 0 {
7246 return Ok(());
7247 };
7248 depth.increment()?;
7249 let envelope_size = 8;
7250 let bytes_len = len * envelope_size;
7251 let offset = decoder.out_of_line_offset(bytes_len)?;
7252 let mut _next_ordinal_to_read = 0;
7254 let mut next_offset = offset;
7255 let end_offset = offset + bytes_len;
7256 _next_ordinal_to_read += 1;
7257 if next_offset >= end_offset {
7258 return Ok(());
7259 }
7260
7261 while _next_ordinal_to_read < 1 {
7263 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7264 _next_ordinal_to_read += 1;
7265 next_offset += envelope_size;
7266 }
7267
7268 let next_out_of_line = decoder.next_out_of_line();
7269 let handles_before = decoder.remaining_handles();
7270 if let Some((inlined, num_bytes, num_handles)) =
7271 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7272 {
7273 let member_inline_size =
7274 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7275 decoder.context,
7276 );
7277 if inlined != (member_inline_size <= 4) {
7278 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7279 }
7280 let inner_offset;
7281 let mut inner_depth = depth.clone();
7282 if inlined {
7283 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7284 inner_offset = next_offset;
7285 } else {
7286 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7287 inner_depth.increment()?;
7288 }
7289 let val_ref = self
7290 .peer_sta_address
7291 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7292 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7293 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7294 {
7295 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7296 }
7297 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7298 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7299 }
7300 }
7301
7302 next_offset += envelope_size;
7303
7304 while next_offset < end_offset {
7306 _next_ordinal_to_read += 1;
7307 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7308 next_offset += envelope_size;
7309 }
7310
7311 Ok(())
7312 }
7313 }
7314
7315 impl WlanFullmacImplIfcDeauthIndRequest {
7316 #[inline(always)]
7317 fn max_ordinal_present(&self) -> u64 {
7318 if let Some(_) = self.locally_initiated {
7319 return 3;
7320 }
7321 if let Some(_) = self.reason_code {
7322 return 2;
7323 }
7324 if let Some(_) = self.peer_sta_address {
7325 return 1;
7326 }
7327 0
7328 }
7329 }
7330
7331 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7332 type Borrowed<'a> = &'a Self;
7333 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7334 value
7335 }
7336 }
7337
7338 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7339 type Owned = Self;
7340
7341 #[inline(always)]
7342 fn inline_align(_context: fidl::encoding::Context) -> usize {
7343 8
7344 }
7345
7346 #[inline(always)]
7347 fn inline_size(_context: fidl::encoding::Context) -> usize {
7348 16
7349 }
7350 }
7351
7352 unsafe impl<D: fidl::encoding::ResourceDialect>
7353 fidl::encoding::Encode<WlanFullmacImplIfcDeauthIndRequest, D>
7354 for &WlanFullmacImplIfcDeauthIndRequest
7355 {
7356 unsafe fn encode(
7357 self,
7358 encoder: &mut fidl::encoding::Encoder<'_, D>,
7359 offset: usize,
7360 mut depth: fidl::encoding::Depth,
7361 ) -> fidl::Result<()> {
7362 encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthIndRequest>(offset);
7363 let max_ordinal: u64 = self.max_ordinal_present();
7365 encoder.write_num(max_ordinal, offset);
7366 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7367 if max_ordinal == 0 {
7369 return Ok(());
7370 }
7371 depth.increment()?;
7372 let envelope_size = 8;
7373 let bytes_len = max_ordinal as usize * envelope_size;
7374 #[allow(unused_variables)]
7375 let offset = encoder.out_of_line_offset(bytes_len);
7376 let mut _prev_end_offset: usize = 0;
7377 if 1 > max_ordinal {
7378 return Ok(());
7379 }
7380
7381 let cur_offset: usize = (1 - 1) * envelope_size;
7384
7385 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7387
7388 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7393 self.peer_sta_address
7394 .as_ref()
7395 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7396 encoder,
7397 offset + cur_offset,
7398 depth,
7399 )?;
7400
7401 _prev_end_offset = cur_offset + envelope_size;
7402 if 2 > max_ordinal {
7403 return Ok(());
7404 }
7405
7406 let cur_offset: usize = (2 - 1) * envelope_size;
7409
7410 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7412
7413 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7418 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7419 encoder, offset + cur_offset, depth
7420 )?;
7421
7422 _prev_end_offset = cur_offset + envelope_size;
7423 if 3 > max_ordinal {
7424 return Ok(());
7425 }
7426
7427 let cur_offset: usize = (3 - 1) * envelope_size;
7430
7431 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7433
7434 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7439 self.locally_initiated
7440 .as_ref()
7441 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7442 encoder,
7443 offset + cur_offset,
7444 depth,
7445 )?;
7446
7447 _prev_end_offset = cur_offset + envelope_size;
7448
7449 Ok(())
7450 }
7451 }
7452
7453 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7454 for WlanFullmacImplIfcDeauthIndRequest
7455 {
7456 #[inline(always)]
7457 fn new_empty() -> Self {
7458 Self::default()
7459 }
7460
7461 unsafe fn decode(
7462 &mut self,
7463 decoder: &mut fidl::encoding::Decoder<'_, D>,
7464 offset: usize,
7465 mut depth: fidl::encoding::Depth,
7466 ) -> fidl::Result<()> {
7467 decoder.debug_check_bounds::<Self>(offset);
7468 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7469 None => return Err(fidl::Error::NotNullable),
7470 Some(len) => len,
7471 };
7472 if len == 0 {
7474 return Ok(());
7475 };
7476 depth.increment()?;
7477 let envelope_size = 8;
7478 let bytes_len = len * envelope_size;
7479 let offset = decoder.out_of_line_offset(bytes_len)?;
7480 let mut _next_ordinal_to_read = 0;
7482 let mut next_offset = offset;
7483 let end_offset = offset + bytes_len;
7484 _next_ordinal_to_read += 1;
7485 if next_offset >= end_offset {
7486 return Ok(());
7487 }
7488
7489 while _next_ordinal_to_read < 1 {
7491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7492 _next_ordinal_to_read += 1;
7493 next_offset += envelope_size;
7494 }
7495
7496 let next_out_of_line = decoder.next_out_of_line();
7497 let handles_before = decoder.remaining_handles();
7498 if let Some((inlined, num_bytes, num_handles)) =
7499 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7500 {
7501 let member_inline_size =
7502 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7503 decoder.context,
7504 );
7505 if inlined != (member_inline_size <= 4) {
7506 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507 }
7508 let inner_offset;
7509 let mut inner_depth = depth.clone();
7510 if inlined {
7511 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512 inner_offset = next_offset;
7513 } else {
7514 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515 inner_depth.increment()?;
7516 }
7517 let val_ref = self
7518 .peer_sta_address
7519 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7520 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7521 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7522 {
7523 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7524 }
7525 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7526 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7527 }
7528 }
7529
7530 next_offset += envelope_size;
7531 _next_ordinal_to_read += 1;
7532 if next_offset >= end_offset {
7533 return Ok(());
7534 }
7535
7536 while _next_ordinal_to_read < 2 {
7538 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7539 _next_ordinal_to_read += 1;
7540 next_offset += envelope_size;
7541 }
7542
7543 let next_out_of_line = decoder.next_out_of_line();
7544 let handles_before = decoder.remaining_handles();
7545 if let Some((inlined, num_bytes, num_handles)) =
7546 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7547 {
7548 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7549 if inlined != (member_inline_size <= 4) {
7550 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7551 }
7552 let inner_offset;
7553 let mut inner_depth = depth.clone();
7554 if inlined {
7555 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7556 inner_offset = next_offset;
7557 } else {
7558 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7559 inner_depth.increment()?;
7560 }
7561 let val_ref = self.reason_code.get_or_insert_with(|| {
7562 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
7563 });
7564 fidl::decode!(
7565 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
7566 D,
7567 val_ref,
7568 decoder,
7569 inner_offset,
7570 inner_depth
7571 )?;
7572 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7573 {
7574 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7575 }
7576 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7577 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7578 }
7579 }
7580
7581 next_offset += envelope_size;
7582 _next_ordinal_to_read += 1;
7583 if next_offset >= end_offset {
7584 return Ok(());
7585 }
7586
7587 while _next_ordinal_to_read < 3 {
7589 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7590 _next_ordinal_to_read += 1;
7591 next_offset += envelope_size;
7592 }
7593
7594 let next_out_of_line = decoder.next_out_of_line();
7595 let handles_before = decoder.remaining_handles();
7596 if let Some((inlined, num_bytes, num_handles)) =
7597 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7598 {
7599 let member_inline_size =
7600 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7601 if inlined != (member_inline_size <= 4) {
7602 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7603 }
7604 let inner_offset;
7605 let mut inner_depth = depth.clone();
7606 if inlined {
7607 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7608 inner_offset = next_offset;
7609 } else {
7610 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7611 inner_depth.increment()?;
7612 }
7613 let val_ref =
7614 self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
7615 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7616 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7617 {
7618 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7619 }
7620 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7621 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7622 }
7623 }
7624
7625 next_offset += envelope_size;
7626
7627 while next_offset < end_offset {
7629 _next_ordinal_to_read += 1;
7630 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7631 next_offset += envelope_size;
7632 }
7633
7634 Ok(())
7635 }
7636 }
7637
7638 impl WlanFullmacImplIfcDisassocConfRequest {
7639 #[inline(always)]
7640 fn max_ordinal_present(&self) -> u64 {
7641 if let Some(_) = self.status {
7642 return 1;
7643 }
7644 0
7645 }
7646 }
7647
7648 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7649 type Borrowed<'a> = &'a Self;
7650 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7651 value
7652 }
7653 }
7654
7655 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7656 type Owned = Self;
7657
7658 #[inline(always)]
7659 fn inline_align(_context: fidl::encoding::Context) -> usize {
7660 8
7661 }
7662
7663 #[inline(always)]
7664 fn inline_size(_context: fidl::encoding::Context) -> usize {
7665 16
7666 }
7667 }
7668
7669 unsafe impl<D: fidl::encoding::ResourceDialect>
7670 fidl::encoding::Encode<WlanFullmacImplIfcDisassocConfRequest, D>
7671 for &WlanFullmacImplIfcDisassocConfRequest
7672 {
7673 unsafe fn encode(
7674 self,
7675 encoder: &mut fidl::encoding::Encoder<'_, D>,
7676 offset: usize,
7677 mut depth: fidl::encoding::Depth,
7678 ) -> fidl::Result<()> {
7679 encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocConfRequest>(offset);
7680 let max_ordinal: u64 = self.max_ordinal_present();
7682 encoder.write_num(max_ordinal, offset);
7683 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7684 if max_ordinal == 0 {
7686 return Ok(());
7687 }
7688 depth.increment()?;
7689 let envelope_size = 8;
7690 let bytes_len = max_ordinal as usize * envelope_size;
7691 #[allow(unused_variables)]
7692 let offset = encoder.out_of_line_offset(bytes_len);
7693 let mut _prev_end_offset: usize = 0;
7694 if 1 > max_ordinal {
7695 return Ok(());
7696 }
7697
7698 let cur_offset: usize = (1 - 1) * envelope_size;
7701
7702 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7704
7705 fidl::encoding::encode_in_envelope_optional::<i32, D>(
7710 self.status.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
7711 encoder,
7712 offset + cur_offset,
7713 depth,
7714 )?;
7715
7716 _prev_end_offset = cur_offset + envelope_size;
7717
7718 Ok(())
7719 }
7720 }
7721
7722 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7723 for WlanFullmacImplIfcDisassocConfRequest
7724 {
7725 #[inline(always)]
7726 fn new_empty() -> Self {
7727 Self::default()
7728 }
7729
7730 unsafe fn decode(
7731 &mut self,
7732 decoder: &mut fidl::encoding::Decoder<'_, D>,
7733 offset: usize,
7734 mut depth: fidl::encoding::Depth,
7735 ) -> fidl::Result<()> {
7736 decoder.debug_check_bounds::<Self>(offset);
7737 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7738 None => return Err(fidl::Error::NotNullable),
7739 Some(len) => len,
7740 };
7741 if len == 0 {
7743 return Ok(());
7744 };
7745 depth.increment()?;
7746 let envelope_size = 8;
7747 let bytes_len = len * envelope_size;
7748 let offset = decoder.out_of_line_offset(bytes_len)?;
7749 let mut _next_ordinal_to_read = 0;
7751 let mut next_offset = offset;
7752 let end_offset = offset + bytes_len;
7753 _next_ordinal_to_read += 1;
7754 if next_offset >= end_offset {
7755 return Ok(());
7756 }
7757
7758 while _next_ordinal_to_read < 1 {
7760 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7761 _next_ordinal_to_read += 1;
7762 next_offset += envelope_size;
7763 }
7764
7765 let next_out_of_line = decoder.next_out_of_line();
7766 let handles_before = decoder.remaining_handles();
7767 if let Some((inlined, num_bytes, num_handles)) =
7768 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7769 {
7770 let member_inline_size =
7771 <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7772 if inlined != (member_inline_size <= 4) {
7773 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7774 }
7775 let inner_offset;
7776 let mut inner_depth = depth.clone();
7777 if inlined {
7778 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7779 inner_offset = next_offset;
7780 } else {
7781 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7782 inner_depth.increment()?;
7783 }
7784 let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(i32, D));
7785 fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
7786 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7787 {
7788 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7789 }
7790 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7791 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7792 }
7793 }
7794
7795 next_offset += envelope_size;
7796
7797 while next_offset < end_offset {
7799 _next_ordinal_to_read += 1;
7800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7801 next_offset += envelope_size;
7802 }
7803
7804 Ok(())
7805 }
7806 }
7807
7808 impl WlanFullmacImplIfcDisassocIndRequest {
7809 #[inline(always)]
7810 fn max_ordinal_present(&self) -> u64 {
7811 if let Some(_) = self.locally_initiated {
7812 return 3;
7813 }
7814 if let Some(_) = self.reason_code {
7815 return 2;
7816 }
7817 if let Some(_) = self.peer_sta_address {
7818 return 1;
7819 }
7820 0
7821 }
7822 }
7823
7824 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7825 type Borrowed<'a> = &'a Self;
7826 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7827 value
7828 }
7829 }
7830
7831 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7832 type Owned = Self;
7833
7834 #[inline(always)]
7835 fn inline_align(_context: fidl::encoding::Context) -> usize {
7836 8
7837 }
7838
7839 #[inline(always)]
7840 fn inline_size(_context: fidl::encoding::Context) -> usize {
7841 16
7842 }
7843 }
7844
7845 unsafe impl<D: fidl::encoding::ResourceDialect>
7846 fidl::encoding::Encode<WlanFullmacImplIfcDisassocIndRequest, D>
7847 for &WlanFullmacImplIfcDisassocIndRequest
7848 {
7849 unsafe fn encode(
7850 self,
7851 encoder: &mut fidl::encoding::Encoder<'_, D>,
7852 offset: usize,
7853 mut depth: fidl::encoding::Depth,
7854 ) -> fidl::Result<()> {
7855 encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocIndRequest>(offset);
7856 let max_ordinal: u64 = self.max_ordinal_present();
7858 encoder.write_num(max_ordinal, offset);
7859 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7860 if max_ordinal == 0 {
7862 return Ok(());
7863 }
7864 depth.increment()?;
7865 let envelope_size = 8;
7866 let bytes_len = max_ordinal as usize * envelope_size;
7867 #[allow(unused_variables)]
7868 let offset = encoder.out_of_line_offset(bytes_len);
7869 let mut _prev_end_offset: usize = 0;
7870 if 1 > max_ordinal {
7871 return Ok(());
7872 }
7873
7874 let cur_offset: usize = (1 - 1) * envelope_size;
7877
7878 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7880
7881 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7886 self.peer_sta_address
7887 .as_ref()
7888 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7889 encoder,
7890 offset + cur_offset,
7891 depth,
7892 )?;
7893
7894 _prev_end_offset = cur_offset + envelope_size;
7895 if 2 > max_ordinal {
7896 return Ok(());
7897 }
7898
7899 let cur_offset: usize = (2 - 1) * envelope_size;
7902
7903 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7905
7906 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7911 self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7912 encoder, offset + cur_offset, depth
7913 )?;
7914
7915 _prev_end_offset = cur_offset + envelope_size;
7916 if 3 > max_ordinal {
7917 return Ok(());
7918 }
7919
7920 let cur_offset: usize = (3 - 1) * envelope_size;
7923
7924 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7926
7927 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7932 self.locally_initiated
7933 .as_ref()
7934 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7935 encoder,
7936 offset + cur_offset,
7937 depth,
7938 )?;
7939
7940 _prev_end_offset = cur_offset + envelope_size;
7941
7942 Ok(())
7943 }
7944 }
7945
7946 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7947 for WlanFullmacImplIfcDisassocIndRequest
7948 {
7949 #[inline(always)]
7950 fn new_empty() -> Self {
7951 Self::default()
7952 }
7953
7954 unsafe fn decode(
7955 &mut self,
7956 decoder: &mut fidl::encoding::Decoder<'_, D>,
7957 offset: usize,
7958 mut depth: fidl::encoding::Depth,
7959 ) -> fidl::Result<()> {
7960 decoder.debug_check_bounds::<Self>(offset);
7961 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7962 None => return Err(fidl::Error::NotNullable),
7963 Some(len) => len,
7964 };
7965 if len == 0 {
7967 return Ok(());
7968 };
7969 depth.increment()?;
7970 let envelope_size = 8;
7971 let bytes_len = len * envelope_size;
7972 let offset = decoder.out_of_line_offset(bytes_len)?;
7973 let mut _next_ordinal_to_read = 0;
7975 let mut next_offset = offset;
7976 let end_offset = offset + bytes_len;
7977 _next_ordinal_to_read += 1;
7978 if next_offset >= end_offset {
7979 return Ok(());
7980 }
7981
7982 while _next_ordinal_to_read < 1 {
7984 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7985 _next_ordinal_to_read += 1;
7986 next_offset += envelope_size;
7987 }
7988
7989 let next_out_of_line = decoder.next_out_of_line();
7990 let handles_before = decoder.remaining_handles();
7991 if let Some((inlined, num_bytes, num_handles)) =
7992 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7993 {
7994 let member_inline_size =
7995 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7996 decoder.context,
7997 );
7998 if inlined != (member_inline_size <= 4) {
7999 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8000 }
8001 let inner_offset;
8002 let mut inner_depth = depth.clone();
8003 if inlined {
8004 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8005 inner_offset = next_offset;
8006 } else {
8007 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8008 inner_depth.increment()?;
8009 }
8010 let val_ref = self
8011 .peer_sta_address
8012 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8013 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8014 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8015 {
8016 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8017 }
8018 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8019 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8020 }
8021 }
8022
8023 next_offset += envelope_size;
8024 _next_ordinal_to_read += 1;
8025 if next_offset >= end_offset {
8026 return Ok(());
8027 }
8028
8029 while _next_ordinal_to_read < 2 {
8031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8032 _next_ordinal_to_read += 1;
8033 next_offset += envelope_size;
8034 }
8035
8036 let next_out_of_line = decoder.next_out_of_line();
8037 let handles_before = decoder.remaining_handles();
8038 if let Some((inlined, num_bytes, num_handles)) =
8039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8040 {
8041 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8042 if inlined != (member_inline_size <= 4) {
8043 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8044 }
8045 let inner_offset;
8046 let mut inner_depth = depth.clone();
8047 if inlined {
8048 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8049 inner_offset = next_offset;
8050 } else {
8051 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8052 inner_depth.increment()?;
8053 }
8054 let val_ref = self.reason_code.get_or_insert_with(|| {
8055 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
8056 });
8057 fidl::decode!(
8058 fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
8059 D,
8060 val_ref,
8061 decoder,
8062 inner_offset,
8063 inner_depth
8064 )?;
8065 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8066 {
8067 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8068 }
8069 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8070 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8071 }
8072 }
8073
8074 next_offset += envelope_size;
8075 _next_ordinal_to_read += 1;
8076 if next_offset >= end_offset {
8077 return Ok(());
8078 }
8079
8080 while _next_ordinal_to_read < 3 {
8082 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8083 _next_ordinal_to_read += 1;
8084 next_offset += envelope_size;
8085 }
8086
8087 let next_out_of_line = decoder.next_out_of_line();
8088 let handles_before = decoder.remaining_handles();
8089 if let Some((inlined, num_bytes, num_handles)) =
8090 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8091 {
8092 let member_inline_size =
8093 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8094 if inlined != (member_inline_size <= 4) {
8095 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8096 }
8097 let inner_offset;
8098 let mut inner_depth = depth.clone();
8099 if inlined {
8100 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8101 inner_offset = next_offset;
8102 } else {
8103 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8104 inner_depth.increment()?;
8105 }
8106 let val_ref =
8107 self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
8108 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8109 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8110 {
8111 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8112 }
8113 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8114 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8115 }
8116 }
8117
8118 next_offset += envelope_size;
8119
8120 while next_offset < end_offset {
8122 _next_ordinal_to_read += 1;
8123 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8124 next_offset += envelope_size;
8125 }
8126
8127 Ok(())
8128 }
8129 }
8130
8131 impl WlanFullmacImplIfcEapolConfRequest {
8132 #[inline(always)]
8133 fn max_ordinal_present(&self) -> u64 {
8134 if let Some(_) = self.dst_addr {
8135 return 2;
8136 }
8137 if let Some(_) = self.result_code {
8138 return 1;
8139 }
8140 0
8141 }
8142 }
8143
8144 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolConfRequest {
8145 type Borrowed<'a> = &'a Self;
8146 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8147 value
8148 }
8149 }
8150
8151 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolConfRequest {
8152 type Owned = Self;
8153
8154 #[inline(always)]
8155 fn inline_align(_context: fidl::encoding::Context) -> usize {
8156 8
8157 }
8158
8159 #[inline(always)]
8160 fn inline_size(_context: fidl::encoding::Context) -> usize {
8161 16
8162 }
8163 }
8164
8165 unsafe impl<D: fidl::encoding::ResourceDialect>
8166 fidl::encoding::Encode<WlanFullmacImplIfcEapolConfRequest, D>
8167 for &WlanFullmacImplIfcEapolConfRequest
8168 {
8169 unsafe fn encode(
8170 self,
8171 encoder: &mut fidl::encoding::Encoder<'_, D>,
8172 offset: usize,
8173 mut depth: fidl::encoding::Depth,
8174 ) -> fidl::Result<()> {
8175 encoder.debug_check_bounds::<WlanFullmacImplIfcEapolConfRequest>(offset);
8176 let max_ordinal: u64 = self.max_ordinal_present();
8178 encoder.write_num(max_ordinal, offset);
8179 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8180 if max_ordinal == 0 {
8182 return Ok(());
8183 }
8184 depth.increment()?;
8185 let envelope_size = 8;
8186 let bytes_len = max_ordinal as usize * envelope_size;
8187 #[allow(unused_variables)]
8188 let offset = encoder.out_of_line_offset(bytes_len);
8189 let mut _prev_end_offset: usize = 0;
8190 if 1 > max_ordinal {
8191 return Ok(());
8192 }
8193
8194 let cur_offset: usize = (1 - 1) * envelope_size;
8197
8198 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8200
8201 fidl::encoding::encode_in_envelope_optional::<EapolTxResult, D>(
8206 self.result_code
8207 .as_ref()
8208 .map(<EapolTxResult as fidl::encoding::ValueTypeMarker>::borrow),
8209 encoder,
8210 offset + cur_offset,
8211 depth,
8212 )?;
8213
8214 _prev_end_offset = cur_offset + envelope_size;
8215 if 2 > max_ordinal {
8216 return Ok(());
8217 }
8218
8219 let cur_offset: usize = (2 - 1) * envelope_size;
8222
8223 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8225
8226 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8231 self.dst_addr
8232 .as_ref()
8233 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8234 encoder,
8235 offset + cur_offset,
8236 depth,
8237 )?;
8238
8239 _prev_end_offset = cur_offset + envelope_size;
8240
8241 Ok(())
8242 }
8243 }
8244
8245 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8246 for WlanFullmacImplIfcEapolConfRequest
8247 {
8248 #[inline(always)]
8249 fn new_empty() -> Self {
8250 Self::default()
8251 }
8252
8253 unsafe fn decode(
8254 &mut self,
8255 decoder: &mut fidl::encoding::Decoder<'_, D>,
8256 offset: usize,
8257 mut depth: fidl::encoding::Depth,
8258 ) -> fidl::Result<()> {
8259 decoder.debug_check_bounds::<Self>(offset);
8260 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8261 None => return Err(fidl::Error::NotNullable),
8262 Some(len) => len,
8263 };
8264 if len == 0 {
8266 return Ok(());
8267 };
8268 depth.increment()?;
8269 let envelope_size = 8;
8270 let bytes_len = len * envelope_size;
8271 let offset = decoder.out_of_line_offset(bytes_len)?;
8272 let mut _next_ordinal_to_read = 0;
8274 let mut next_offset = offset;
8275 let end_offset = offset + bytes_len;
8276 _next_ordinal_to_read += 1;
8277 if next_offset >= end_offset {
8278 return Ok(());
8279 }
8280
8281 while _next_ordinal_to_read < 1 {
8283 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8284 _next_ordinal_to_read += 1;
8285 next_offset += envelope_size;
8286 }
8287
8288 let next_out_of_line = decoder.next_out_of_line();
8289 let handles_before = decoder.remaining_handles();
8290 if let Some((inlined, num_bytes, num_handles)) =
8291 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8292 {
8293 let member_inline_size =
8294 <EapolTxResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8295 if inlined != (member_inline_size <= 4) {
8296 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8297 }
8298 let inner_offset;
8299 let mut inner_depth = depth.clone();
8300 if inlined {
8301 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8302 inner_offset = next_offset;
8303 } else {
8304 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8305 inner_depth.increment()?;
8306 }
8307 let val_ref =
8308 self.result_code.get_or_insert_with(|| fidl::new_empty!(EapolTxResult, D));
8309 fidl::decode!(EapolTxResult, D, val_ref, decoder, inner_offset, inner_depth)?;
8310 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8311 {
8312 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8313 }
8314 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8315 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8316 }
8317 }
8318
8319 next_offset += envelope_size;
8320 _next_ordinal_to_read += 1;
8321 if next_offset >= end_offset {
8322 return Ok(());
8323 }
8324
8325 while _next_ordinal_to_read < 2 {
8327 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8328 _next_ordinal_to_read += 1;
8329 next_offset += envelope_size;
8330 }
8331
8332 let next_out_of_line = decoder.next_out_of_line();
8333 let handles_before = decoder.remaining_handles();
8334 if let Some((inlined, num_bytes, num_handles)) =
8335 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8336 {
8337 let member_inline_size =
8338 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8339 decoder.context,
8340 );
8341 if inlined != (member_inline_size <= 4) {
8342 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8343 }
8344 let inner_offset;
8345 let mut inner_depth = depth.clone();
8346 if inlined {
8347 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8348 inner_offset = next_offset;
8349 } else {
8350 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8351 inner_depth.increment()?;
8352 }
8353 let val_ref = self
8354 .dst_addr
8355 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8356 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8357 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8358 {
8359 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8360 }
8361 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8362 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8363 }
8364 }
8365
8366 next_offset += envelope_size;
8367
8368 while next_offset < end_offset {
8370 _next_ordinal_to_read += 1;
8371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8372 next_offset += envelope_size;
8373 }
8374
8375 Ok(())
8376 }
8377 }
8378
8379 impl WlanFullmacImplIfcEapolIndRequest {
8380 #[inline(always)]
8381 fn max_ordinal_present(&self) -> u64 {
8382 if let Some(_) = self.data {
8383 return 3;
8384 }
8385 if let Some(_) = self.dst_addr {
8386 return 2;
8387 }
8388 if let Some(_) = self.src_addr {
8389 return 1;
8390 }
8391 0
8392 }
8393 }
8394
8395 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolIndRequest {
8396 type Borrowed<'a> = &'a Self;
8397 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8398 value
8399 }
8400 }
8401
8402 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolIndRequest {
8403 type Owned = Self;
8404
8405 #[inline(always)]
8406 fn inline_align(_context: fidl::encoding::Context) -> usize {
8407 8
8408 }
8409
8410 #[inline(always)]
8411 fn inline_size(_context: fidl::encoding::Context) -> usize {
8412 16
8413 }
8414 }
8415
8416 unsafe impl<D: fidl::encoding::ResourceDialect>
8417 fidl::encoding::Encode<WlanFullmacImplIfcEapolIndRequest, D>
8418 for &WlanFullmacImplIfcEapolIndRequest
8419 {
8420 unsafe fn encode(
8421 self,
8422 encoder: &mut fidl::encoding::Encoder<'_, D>,
8423 offset: usize,
8424 mut depth: fidl::encoding::Depth,
8425 ) -> fidl::Result<()> {
8426 encoder.debug_check_bounds::<WlanFullmacImplIfcEapolIndRequest>(offset);
8427 let max_ordinal: u64 = self.max_ordinal_present();
8429 encoder.write_num(max_ordinal, offset);
8430 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8431 if max_ordinal == 0 {
8433 return Ok(());
8434 }
8435 depth.increment()?;
8436 let envelope_size = 8;
8437 let bytes_len = max_ordinal as usize * envelope_size;
8438 #[allow(unused_variables)]
8439 let offset = encoder.out_of_line_offset(bytes_len);
8440 let mut _prev_end_offset: usize = 0;
8441 if 1 > max_ordinal {
8442 return Ok(());
8443 }
8444
8445 let cur_offset: usize = (1 - 1) * envelope_size;
8448
8449 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8451
8452 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8457 self.src_addr
8458 .as_ref()
8459 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8460 encoder,
8461 offset + cur_offset,
8462 depth,
8463 )?;
8464
8465 _prev_end_offset = cur_offset + envelope_size;
8466 if 2 > max_ordinal {
8467 return Ok(());
8468 }
8469
8470 let cur_offset: usize = (2 - 1) * envelope_size;
8473
8474 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8476
8477 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8482 self.dst_addr
8483 .as_ref()
8484 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8485 encoder,
8486 offset + cur_offset,
8487 depth,
8488 )?;
8489
8490 _prev_end_offset = cur_offset + envelope_size;
8491 if 3 > max_ordinal {
8492 return Ok(());
8493 }
8494
8495 let cur_offset: usize = (3 - 1) * envelope_size;
8498
8499 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8501
8502 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8507 self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8508 encoder, offset + cur_offset, depth
8509 )?;
8510
8511 _prev_end_offset = cur_offset + envelope_size;
8512
8513 Ok(())
8514 }
8515 }
8516
8517 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8518 for WlanFullmacImplIfcEapolIndRequest
8519 {
8520 #[inline(always)]
8521 fn new_empty() -> Self {
8522 Self::default()
8523 }
8524
8525 unsafe fn decode(
8526 &mut self,
8527 decoder: &mut fidl::encoding::Decoder<'_, D>,
8528 offset: usize,
8529 mut depth: fidl::encoding::Depth,
8530 ) -> fidl::Result<()> {
8531 decoder.debug_check_bounds::<Self>(offset);
8532 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8533 None => return Err(fidl::Error::NotNullable),
8534 Some(len) => len,
8535 };
8536 if len == 0 {
8538 return Ok(());
8539 };
8540 depth.increment()?;
8541 let envelope_size = 8;
8542 let bytes_len = len * envelope_size;
8543 let offset = decoder.out_of_line_offset(bytes_len)?;
8544 let mut _next_ordinal_to_read = 0;
8546 let mut next_offset = offset;
8547 let end_offset = offset + bytes_len;
8548 _next_ordinal_to_read += 1;
8549 if next_offset >= end_offset {
8550 return Ok(());
8551 }
8552
8553 while _next_ordinal_to_read < 1 {
8555 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8556 _next_ordinal_to_read += 1;
8557 next_offset += envelope_size;
8558 }
8559
8560 let next_out_of_line = decoder.next_out_of_line();
8561 let handles_before = decoder.remaining_handles();
8562 if let Some((inlined, num_bytes, num_handles)) =
8563 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8564 {
8565 let member_inline_size =
8566 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8567 decoder.context,
8568 );
8569 if inlined != (member_inline_size <= 4) {
8570 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8571 }
8572 let inner_offset;
8573 let mut inner_depth = depth.clone();
8574 if inlined {
8575 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8576 inner_offset = next_offset;
8577 } else {
8578 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8579 inner_depth.increment()?;
8580 }
8581 let val_ref = self
8582 .src_addr
8583 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8584 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8585 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8586 {
8587 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8588 }
8589 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8590 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8591 }
8592 }
8593
8594 next_offset += envelope_size;
8595 _next_ordinal_to_read += 1;
8596 if next_offset >= end_offset {
8597 return Ok(());
8598 }
8599
8600 while _next_ordinal_to_read < 2 {
8602 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8603 _next_ordinal_to_read += 1;
8604 next_offset += envelope_size;
8605 }
8606
8607 let next_out_of_line = decoder.next_out_of_line();
8608 let handles_before = decoder.remaining_handles();
8609 if let Some((inlined, num_bytes, num_handles)) =
8610 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8611 {
8612 let member_inline_size =
8613 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8614 decoder.context,
8615 );
8616 if inlined != (member_inline_size <= 4) {
8617 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8618 }
8619 let inner_offset;
8620 let mut inner_depth = depth.clone();
8621 if inlined {
8622 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8623 inner_offset = next_offset;
8624 } else {
8625 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8626 inner_depth.increment()?;
8627 }
8628 let val_ref = self
8629 .dst_addr
8630 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8631 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8632 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8633 {
8634 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8635 }
8636 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8637 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8638 }
8639 }
8640
8641 next_offset += envelope_size;
8642 _next_ordinal_to_read += 1;
8643 if next_offset >= end_offset {
8644 return Ok(());
8645 }
8646
8647 while _next_ordinal_to_read < 3 {
8649 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8650 _next_ordinal_to_read += 1;
8651 next_offset += envelope_size;
8652 }
8653
8654 let next_out_of_line = decoder.next_out_of_line();
8655 let handles_before = decoder.remaining_handles();
8656 if let Some((inlined, num_bytes, num_handles)) =
8657 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8658 {
8659 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8660 if inlined != (member_inline_size <= 4) {
8661 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8662 }
8663 let inner_offset;
8664 let mut inner_depth = depth.clone();
8665 if inlined {
8666 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8667 inner_offset = next_offset;
8668 } else {
8669 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8670 inner_depth.increment()?;
8671 }
8672 let val_ref = self.data.get_or_insert_with(|| {
8673 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8674 });
8675 fidl::decode!(
8676 fidl::encoding::UnboundedVector<u8>,
8677 D,
8678 val_ref,
8679 decoder,
8680 inner_offset,
8681 inner_depth
8682 )?;
8683 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8684 {
8685 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8686 }
8687 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8688 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8689 }
8690 }
8691
8692 next_offset += envelope_size;
8693
8694 while next_offset < end_offset {
8696 _next_ordinal_to_read += 1;
8697 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8698 next_offset += envelope_size;
8699 }
8700
8701 Ok(())
8702 }
8703 }
8704
8705 impl WlanFullmacImplIfcOnPmkAvailableRequest {
8706 #[inline(always)]
8707 fn max_ordinal_present(&self) -> u64 {
8708 if let Some(_) = self.pmkid {
8709 return 2;
8710 }
8711 if let Some(_) = self.pmk {
8712 return 1;
8713 }
8714 0
8715 }
8716 }
8717
8718 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8719 type Borrowed<'a> = &'a Self;
8720 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8721 value
8722 }
8723 }
8724
8725 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8726 type Owned = Self;
8727
8728 #[inline(always)]
8729 fn inline_align(_context: fidl::encoding::Context) -> usize {
8730 8
8731 }
8732
8733 #[inline(always)]
8734 fn inline_size(_context: fidl::encoding::Context) -> usize {
8735 16
8736 }
8737 }
8738
8739 unsafe impl<D: fidl::encoding::ResourceDialect>
8740 fidl::encoding::Encode<WlanFullmacImplIfcOnPmkAvailableRequest, D>
8741 for &WlanFullmacImplIfcOnPmkAvailableRequest
8742 {
8743 unsafe fn encode(
8744 self,
8745 encoder: &mut fidl::encoding::Encoder<'_, D>,
8746 offset: usize,
8747 mut depth: fidl::encoding::Depth,
8748 ) -> fidl::Result<()> {
8749 encoder.debug_check_bounds::<WlanFullmacImplIfcOnPmkAvailableRequest>(offset);
8750 let max_ordinal: u64 = self.max_ordinal_present();
8752 encoder.write_num(max_ordinal, offset);
8753 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8754 if max_ordinal == 0 {
8756 return Ok(());
8757 }
8758 depth.increment()?;
8759 let envelope_size = 8;
8760 let bytes_len = max_ordinal as usize * envelope_size;
8761 #[allow(unused_variables)]
8762 let offset = encoder.out_of_line_offset(bytes_len);
8763 let mut _prev_end_offset: usize = 0;
8764 if 1 > max_ordinal {
8765 return Ok(());
8766 }
8767
8768 let cur_offset: usize = (1 - 1) * envelope_size;
8771
8772 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8774
8775 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8780 self.pmk.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8781 encoder, offset + cur_offset, depth
8782 )?;
8783
8784 _prev_end_offset = cur_offset + envelope_size;
8785 if 2 > max_ordinal {
8786 return Ok(());
8787 }
8788
8789 let cur_offset: usize = (2 - 1) * envelope_size;
8792
8793 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8795
8796 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8801 self.pmkid.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8802 encoder, offset + cur_offset, depth
8803 )?;
8804
8805 _prev_end_offset = cur_offset + envelope_size;
8806
8807 Ok(())
8808 }
8809 }
8810
8811 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8812 for WlanFullmacImplIfcOnPmkAvailableRequest
8813 {
8814 #[inline(always)]
8815 fn new_empty() -> Self {
8816 Self::default()
8817 }
8818
8819 unsafe fn decode(
8820 &mut self,
8821 decoder: &mut fidl::encoding::Decoder<'_, D>,
8822 offset: usize,
8823 mut depth: fidl::encoding::Depth,
8824 ) -> fidl::Result<()> {
8825 decoder.debug_check_bounds::<Self>(offset);
8826 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8827 None => return Err(fidl::Error::NotNullable),
8828 Some(len) => len,
8829 };
8830 if len == 0 {
8832 return Ok(());
8833 };
8834 depth.increment()?;
8835 let envelope_size = 8;
8836 let bytes_len = len * envelope_size;
8837 let offset = decoder.out_of_line_offset(bytes_len)?;
8838 let mut _next_ordinal_to_read = 0;
8840 let mut next_offset = offset;
8841 let end_offset = offset + bytes_len;
8842 _next_ordinal_to_read += 1;
8843 if next_offset >= end_offset {
8844 return Ok(());
8845 }
8846
8847 while _next_ordinal_to_read < 1 {
8849 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8850 _next_ordinal_to_read += 1;
8851 next_offset += envelope_size;
8852 }
8853
8854 let next_out_of_line = decoder.next_out_of_line();
8855 let handles_before = decoder.remaining_handles();
8856 if let Some((inlined, num_bytes, num_handles)) =
8857 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8858 {
8859 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8860 if inlined != (member_inline_size <= 4) {
8861 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8862 }
8863 let inner_offset;
8864 let mut inner_depth = depth.clone();
8865 if inlined {
8866 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8867 inner_offset = next_offset;
8868 } else {
8869 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8870 inner_depth.increment()?;
8871 }
8872 let val_ref = self.pmk.get_or_insert_with(|| {
8873 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8874 });
8875 fidl::decode!(
8876 fidl::encoding::UnboundedVector<u8>,
8877 D,
8878 val_ref,
8879 decoder,
8880 inner_offset,
8881 inner_depth
8882 )?;
8883 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8884 {
8885 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8886 }
8887 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8888 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8889 }
8890 }
8891
8892 next_offset += envelope_size;
8893 _next_ordinal_to_read += 1;
8894 if next_offset >= end_offset {
8895 return Ok(());
8896 }
8897
8898 while _next_ordinal_to_read < 2 {
8900 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8901 _next_ordinal_to_read += 1;
8902 next_offset += envelope_size;
8903 }
8904
8905 let next_out_of_line = decoder.next_out_of_line();
8906 let handles_before = decoder.remaining_handles();
8907 if let Some((inlined, num_bytes, num_handles)) =
8908 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8909 {
8910 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8911 if inlined != (member_inline_size <= 4) {
8912 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8913 }
8914 let inner_offset;
8915 let mut inner_depth = depth.clone();
8916 if inlined {
8917 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8918 inner_offset = next_offset;
8919 } else {
8920 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8921 inner_depth.increment()?;
8922 }
8923 let val_ref = self.pmkid.get_or_insert_with(|| {
8924 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8925 });
8926 fidl::decode!(
8927 fidl::encoding::UnboundedVector<u8>,
8928 D,
8929 val_ref,
8930 decoder,
8931 inner_offset,
8932 inner_depth
8933 )?;
8934 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8935 {
8936 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8937 }
8938 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8939 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8940 }
8941 }
8942
8943 next_offset += envelope_size;
8944
8945 while next_offset < end_offset {
8947 _next_ordinal_to_read += 1;
8948 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8949 next_offset += envelope_size;
8950 }
8951
8952 Ok(())
8953 }
8954 }
8955
8956 impl WlanFullmacImplIfcOnScanEndRequest {
8957 #[inline(always)]
8958 fn max_ordinal_present(&self) -> u64 {
8959 if let Some(_) = self.code {
8960 return 2;
8961 }
8962 if let Some(_) = self.txn_id {
8963 return 1;
8964 }
8965 0
8966 }
8967 }
8968
8969 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanEndRequest {
8970 type Borrowed<'a> = &'a Self;
8971 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8972 value
8973 }
8974 }
8975
8976 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanEndRequest {
8977 type Owned = Self;
8978
8979 #[inline(always)]
8980 fn inline_align(_context: fidl::encoding::Context) -> usize {
8981 8
8982 }
8983
8984 #[inline(always)]
8985 fn inline_size(_context: fidl::encoding::Context) -> usize {
8986 16
8987 }
8988 }
8989
8990 unsafe impl<D: fidl::encoding::ResourceDialect>
8991 fidl::encoding::Encode<WlanFullmacImplIfcOnScanEndRequest, D>
8992 for &WlanFullmacImplIfcOnScanEndRequest
8993 {
8994 unsafe fn encode(
8995 self,
8996 encoder: &mut fidl::encoding::Encoder<'_, D>,
8997 offset: usize,
8998 mut depth: fidl::encoding::Depth,
8999 ) -> fidl::Result<()> {
9000 encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanEndRequest>(offset);
9001 let max_ordinal: u64 = self.max_ordinal_present();
9003 encoder.write_num(max_ordinal, offset);
9004 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9005 if max_ordinal == 0 {
9007 return Ok(());
9008 }
9009 depth.increment()?;
9010 let envelope_size = 8;
9011 let bytes_len = max_ordinal as usize * envelope_size;
9012 #[allow(unused_variables)]
9013 let offset = encoder.out_of_line_offset(bytes_len);
9014 let mut _prev_end_offset: usize = 0;
9015 if 1 > max_ordinal {
9016 return Ok(());
9017 }
9018
9019 let cur_offset: usize = (1 - 1) * envelope_size;
9022
9023 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9025
9026 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9031 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9032 encoder,
9033 offset + cur_offset,
9034 depth,
9035 )?;
9036
9037 _prev_end_offset = cur_offset + envelope_size;
9038 if 2 > max_ordinal {
9039 return Ok(());
9040 }
9041
9042 let cur_offset: usize = (2 - 1) * envelope_size;
9045
9046 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9048
9049 fidl::encoding::encode_in_envelope_optional::<WlanScanResult, D>(
9054 self.code.as_ref().map(<WlanScanResult as fidl::encoding::ValueTypeMarker>::borrow),
9055 encoder,
9056 offset + cur_offset,
9057 depth,
9058 )?;
9059
9060 _prev_end_offset = cur_offset + envelope_size;
9061
9062 Ok(())
9063 }
9064 }
9065
9066 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9067 for WlanFullmacImplIfcOnScanEndRequest
9068 {
9069 #[inline(always)]
9070 fn new_empty() -> Self {
9071 Self::default()
9072 }
9073
9074 unsafe fn decode(
9075 &mut self,
9076 decoder: &mut fidl::encoding::Decoder<'_, D>,
9077 offset: usize,
9078 mut depth: fidl::encoding::Depth,
9079 ) -> fidl::Result<()> {
9080 decoder.debug_check_bounds::<Self>(offset);
9081 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9082 None => return Err(fidl::Error::NotNullable),
9083 Some(len) => len,
9084 };
9085 if len == 0 {
9087 return Ok(());
9088 };
9089 depth.increment()?;
9090 let envelope_size = 8;
9091 let bytes_len = len * envelope_size;
9092 let offset = decoder.out_of_line_offset(bytes_len)?;
9093 let mut _next_ordinal_to_read = 0;
9095 let mut next_offset = offset;
9096 let end_offset = offset + bytes_len;
9097 _next_ordinal_to_read += 1;
9098 if next_offset >= end_offset {
9099 return Ok(());
9100 }
9101
9102 while _next_ordinal_to_read < 1 {
9104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9105 _next_ordinal_to_read += 1;
9106 next_offset += envelope_size;
9107 }
9108
9109 let next_out_of_line = decoder.next_out_of_line();
9110 let handles_before = decoder.remaining_handles();
9111 if let Some((inlined, num_bytes, num_handles)) =
9112 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9113 {
9114 let member_inline_size =
9115 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9116 if inlined != (member_inline_size <= 4) {
9117 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9118 }
9119 let inner_offset;
9120 let mut inner_depth = depth.clone();
9121 if inlined {
9122 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9123 inner_offset = next_offset;
9124 } else {
9125 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9126 inner_depth.increment()?;
9127 }
9128 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9129 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9130 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9131 {
9132 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9133 }
9134 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9135 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9136 }
9137 }
9138
9139 next_offset += envelope_size;
9140 _next_ordinal_to_read += 1;
9141 if next_offset >= end_offset {
9142 return Ok(());
9143 }
9144
9145 while _next_ordinal_to_read < 2 {
9147 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9148 _next_ordinal_to_read += 1;
9149 next_offset += envelope_size;
9150 }
9151
9152 let next_out_of_line = decoder.next_out_of_line();
9153 let handles_before = decoder.remaining_handles();
9154 if let Some((inlined, num_bytes, num_handles)) =
9155 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9156 {
9157 let member_inline_size =
9158 <WlanScanResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9159 if inlined != (member_inline_size <= 4) {
9160 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9161 }
9162 let inner_offset;
9163 let mut inner_depth = depth.clone();
9164 if inlined {
9165 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9166 inner_offset = next_offset;
9167 } else {
9168 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9169 inner_depth.increment()?;
9170 }
9171 let val_ref = self.code.get_or_insert_with(|| fidl::new_empty!(WlanScanResult, D));
9172 fidl::decode!(WlanScanResult, D, val_ref, decoder, inner_offset, inner_depth)?;
9173 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9174 {
9175 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9176 }
9177 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9178 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9179 }
9180 }
9181
9182 next_offset += envelope_size;
9183
9184 while next_offset < end_offset {
9186 _next_ordinal_to_read += 1;
9187 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9188 next_offset += envelope_size;
9189 }
9190
9191 Ok(())
9192 }
9193 }
9194
9195 impl WlanFullmacImplIfcOnScanResultRequest {
9196 #[inline(always)]
9197 fn max_ordinal_present(&self) -> u64 {
9198 if let Some(_) = self.bss {
9199 return 3;
9200 }
9201 if let Some(_) = self.timestamp_nanos {
9202 return 2;
9203 }
9204 if let Some(_) = self.txn_id {
9205 return 1;
9206 }
9207 0
9208 }
9209 }
9210
9211 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9212 type Borrowed<'a> = &'a Self;
9213 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9214 value
9215 }
9216 }
9217
9218 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9219 type Owned = Self;
9220
9221 #[inline(always)]
9222 fn inline_align(_context: fidl::encoding::Context) -> usize {
9223 8
9224 }
9225
9226 #[inline(always)]
9227 fn inline_size(_context: fidl::encoding::Context) -> usize {
9228 16
9229 }
9230 }
9231
9232 unsafe impl<D: fidl::encoding::ResourceDialect>
9233 fidl::encoding::Encode<WlanFullmacImplIfcOnScanResultRequest, D>
9234 for &WlanFullmacImplIfcOnScanResultRequest
9235 {
9236 unsafe fn encode(
9237 self,
9238 encoder: &mut fidl::encoding::Encoder<'_, D>,
9239 offset: usize,
9240 mut depth: fidl::encoding::Depth,
9241 ) -> fidl::Result<()> {
9242 encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanResultRequest>(offset);
9243 let max_ordinal: u64 = self.max_ordinal_present();
9245 encoder.write_num(max_ordinal, offset);
9246 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9247 if max_ordinal == 0 {
9249 return Ok(());
9250 }
9251 depth.increment()?;
9252 let envelope_size = 8;
9253 let bytes_len = max_ordinal as usize * envelope_size;
9254 #[allow(unused_variables)]
9255 let offset = encoder.out_of_line_offset(bytes_len);
9256 let mut _prev_end_offset: usize = 0;
9257 if 1 > max_ordinal {
9258 return Ok(());
9259 }
9260
9261 let cur_offset: usize = (1 - 1) * envelope_size;
9264
9265 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9267
9268 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9273 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9274 encoder,
9275 offset + cur_offset,
9276 depth,
9277 )?;
9278
9279 _prev_end_offset = cur_offset + envelope_size;
9280 if 2 > max_ordinal {
9281 return Ok(());
9282 }
9283
9284 let cur_offset: usize = (2 - 1) * envelope_size;
9287
9288 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9290
9291 fidl::encoding::encode_in_envelope_optional::<i64, D>(
9296 self.timestamp_nanos.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9297 encoder,
9298 offset + cur_offset,
9299 depth,
9300 )?;
9301
9302 _prev_end_offset = cur_offset + envelope_size;
9303 if 3 > max_ordinal {
9304 return Ok(());
9305 }
9306
9307 let cur_offset: usize = (3 - 1) * envelope_size;
9310
9311 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9313
9314 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
9319 self.bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
9320 encoder, offset + cur_offset, depth
9321 )?;
9322
9323 _prev_end_offset = cur_offset + envelope_size;
9324
9325 Ok(())
9326 }
9327 }
9328
9329 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9330 for WlanFullmacImplIfcOnScanResultRequest
9331 {
9332 #[inline(always)]
9333 fn new_empty() -> Self {
9334 Self::default()
9335 }
9336
9337 unsafe fn decode(
9338 &mut self,
9339 decoder: &mut fidl::encoding::Decoder<'_, D>,
9340 offset: usize,
9341 mut depth: fidl::encoding::Depth,
9342 ) -> fidl::Result<()> {
9343 decoder.debug_check_bounds::<Self>(offset);
9344 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9345 None => return Err(fidl::Error::NotNullable),
9346 Some(len) => len,
9347 };
9348 if len == 0 {
9350 return Ok(());
9351 };
9352 depth.increment()?;
9353 let envelope_size = 8;
9354 let bytes_len = len * envelope_size;
9355 let offset = decoder.out_of_line_offset(bytes_len)?;
9356 let mut _next_ordinal_to_read = 0;
9358 let mut next_offset = offset;
9359 let end_offset = offset + bytes_len;
9360 _next_ordinal_to_read += 1;
9361 if next_offset >= end_offset {
9362 return Ok(());
9363 }
9364
9365 while _next_ordinal_to_read < 1 {
9367 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9368 _next_ordinal_to_read += 1;
9369 next_offset += envelope_size;
9370 }
9371
9372 let next_out_of_line = decoder.next_out_of_line();
9373 let handles_before = decoder.remaining_handles();
9374 if let Some((inlined, num_bytes, num_handles)) =
9375 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9376 {
9377 let member_inline_size =
9378 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9379 if inlined != (member_inline_size <= 4) {
9380 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9381 }
9382 let inner_offset;
9383 let mut inner_depth = depth.clone();
9384 if inlined {
9385 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9386 inner_offset = next_offset;
9387 } else {
9388 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9389 inner_depth.increment()?;
9390 }
9391 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9392 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9393 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9394 {
9395 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9396 }
9397 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9398 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9399 }
9400 }
9401
9402 next_offset += envelope_size;
9403 _next_ordinal_to_read += 1;
9404 if next_offset >= end_offset {
9405 return Ok(());
9406 }
9407
9408 while _next_ordinal_to_read < 2 {
9410 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9411 _next_ordinal_to_read += 1;
9412 next_offset += envelope_size;
9413 }
9414
9415 let next_out_of_line = decoder.next_out_of_line();
9416 let handles_before = decoder.remaining_handles();
9417 if let Some((inlined, num_bytes, num_handles)) =
9418 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9419 {
9420 let member_inline_size =
9421 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9422 if inlined != (member_inline_size <= 4) {
9423 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9424 }
9425 let inner_offset;
9426 let mut inner_depth = depth.clone();
9427 if inlined {
9428 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9429 inner_offset = next_offset;
9430 } else {
9431 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9432 inner_depth.increment()?;
9433 }
9434 let val_ref = self.timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(i64, D));
9435 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9436 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9437 {
9438 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9439 }
9440 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9441 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9442 }
9443 }
9444
9445 next_offset += envelope_size;
9446 _next_ordinal_to_read += 1;
9447 if next_offset >= end_offset {
9448 return Ok(());
9449 }
9450
9451 while _next_ordinal_to_read < 3 {
9453 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9454 _next_ordinal_to_read += 1;
9455 next_offset += envelope_size;
9456 }
9457
9458 let next_out_of_line = decoder.next_out_of_line();
9459 let handles_before = decoder.remaining_handles();
9460 if let Some((inlined, num_bytes, num_handles)) =
9461 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9462 {
9463 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9464 if inlined != (member_inline_size <= 4) {
9465 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9466 }
9467 let inner_offset;
9468 let mut inner_depth = depth.clone();
9469 if inlined {
9470 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9471 inner_offset = next_offset;
9472 } else {
9473 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9474 inner_depth.increment()?;
9475 }
9476 let val_ref = self.bss.get_or_insert_with(|| {
9477 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
9478 });
9479 fidl::decode!(
9480 fidl_fuchsia_wlan_common__common::BssDescription,
9481 D,
9482 val_ref,
9483 decoder,
9484 inner_offset,
9485 inner_depth
9486 )?;
9487 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9488 {
9489 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9490 }
9491 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9492 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9493 }
9494 }
9495
9496 next_offset += envelope_size;
9497
9498 while next_offset < end_offset {
9500 _next_ordinal_to_read += 1;
9501 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9502 next_offset += envelope_size;
9503 }
9504
9505 Ok(())
9506 }
9507 }
9508
9509 impl WlanFullmacImplIfcRoamConfRequest {
9510 #[inline(always)]
9511 fn max_ordinal_present(&self) -> u64 {
9512 if let Some(_) = self.association_ies {
9513 return 6;
9514 }
9515 if let Some(_) = self.association_id {
9516 return 5;
9517 }
9518 if let Some(_) = self.target_bss_authenticated {
9519 return 4;
9520 }
9521 if let Some(_) = self.original_association_maintained {
9522 return 3;
9523 }
9524 if let Some(_) = self.status_code {
9525 return 2;
9526 }
9527 if let Some(_) = self.selected_bssid {
9528 return 1;
9529 }
9530 0
9531 }
9532 }
9533
9534 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamConfRequest {
9535 type Borrowed<'a> = &'a Self;
9536 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9537 value
9538 }
9539 }
9540
9541 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamConfRequest {
9542 type Owned = Self;
9543
9544 #[inline(always)]
9545 fn inline_align(_context: fidl::encoding::Context) -> usize {
9546 8
9547 }
9548
9549 #[inline(always)]
9550 fn inline_size(_context: fidl::encoding::Context) -> usize {
9551 16
9552 }
9553 }
9554
9555 unsafe impl<D: fidl::encoding::ResourceDialect>
9556 fidl::encoding::Encode<WlanFullmacImplIfcRoamConfRequest, D>
9557 for &WlanFullmacImplIfcRoamConfRequest
9558 {
9559 unsafe fn encode(
9560 self,
9561 encoder: &mut fidl::encoding::Encoder<'_, D>,
9562 offset: usize,
9563 mut depth: fidl::encoding::Depth,
9564 ) -> fidl::Result<()> {
9565 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamConfRequest>(offset);
9566 let max_ordinal: u64 = self.max_ordinal_present();
9568 encoder.write_num(max_ordinal, offset);
9569 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9570 if max_ordinal == 0 {
9572 return Ok(());
9573 }
9574 depth.increment()?;
9575 let envelope_size = 8;
9576 let bytes_len = max_ordinal as usize * envelope_size;
9577 #[allow(unused_variables)]
9578 let offset = encoder.out_of_line_offset(bytes_len);
9579 let mut _prev_end_offset: usize = 0;
9580 if 1 > max_ordinal {
9581 return Ok(());
9582 }
9583
9584 let cur_offset: usize = (1 - 1) * envelope_size;
9587
9588 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9590
9591 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
9596 self.selected_bssid
9597 .as_ref()
9598 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
9599 encoder,
9600 offset + cur_offset,
9601 depth,
9602 )?;
9603
9604 _prev_end_offset = cur_offset + envelope_size;
9605 if 2 > max_ordinal {
9606 return Ok(());
9607 }
9608
9609 let cur_offset: usize = (2 - 1) * envelope_size;
9612
9613 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9615
9616 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
9621 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
9622 encoder, offset + cur_offset, depth
9623 )?;
9624
9625 _prev_end_offset = cur_offset + envelope_size;
9626 if 3 > max_ordinal {
9627 return Ok(());
9628 }
9629
9630 let cur_offset: usize = (3 - 1) * envelope_size;
9633
9634 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9636
9637 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9642 self.original_association_maintained
9643 .as_ref()
9644 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9645 encoder,
9646 offset + cur_offset,
9647 depth,
9648 )?;
9649
9650 _prev_end_offset = cur_offset + envelope_size;
9651 if 4 > max_ordinal {
9652 return Ok(());
9653 }
9654
9655 let cur_offset: usize = (4 - 1) * envelope_size;
9658
9659 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9661
9662 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9667 self.target_bss_authenticated
9668 .as_ref()
9669 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9670 encoder,
9671 offset + cur_offset,
9672 depth,
9673 )?;
9674
9675 _prev_end_offset = cur_offset + envelope_size;
9676 if 5 > max_ordinal {
9677 return Ok(());
9678 }
9679
9680 let cur_offset: usize = (5 - 1) * envelope_size;
9683
9684 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9686
9687 fidl::encoding::encode_in_envelope_optional::<u16, D>(
9692 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9693 encoder,
9694 offset + cur_offset,
9695 depth,
9696 )?;
9697
9698 _prev_end_offset = cur_offset + envelope_size;
9699 if 6 > max_ordinal {
9700 return Ok(());
9701 }
9702
9703 let cur_offset: usize = (6 - 1) * envelope_size;
9706
9707 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9709
9710 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
9715 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
9716 encoder, offset + cur_offset, depth
9717 )?;
9718
9719 _prev_end_offset = cur_offset + envelope_size;
9720
9721 Ok(())
9722 }
9723 }
9724
9725 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9726 for WlanFullmacImplIfcRoamConfRequest
9727 {
9728 #[inline(always)]
9729 fn new_empty() -> Self {
9730 Self::default()
9731 }
9732
9733 unsafe fn decode(
9734 &mut self,
9735 decoder: &mut fidl::encoding::Decoder<'_, D>,
9736 offset: usize,
9737 mut depth: fidl::encoding::Depth,
9738 ) -> fidl::Result<()> {
9739 decoder.debug_check_bounds::<Self>(offset);
9740 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9741 None => return Err(fidl::Error::NotNullable),
9742 Some(len) => len,
9743 };
9744 if len == 0 {
9746 return Ok(());
9747 };
9748 depth.increment()?;
9749 let envelope_size = 8;
9750 let bytes_len = len * envelope_size;
9751 let offset = decoder.out_of_line_offset(bytes_len)?;
9752 let mut _next_ordinal_to_read = 0;
9754 let mut next_offset = offset;
9755 let end_offset = offset + bytes_len;
9756 _next_ordinal_to_read += 1;
9757 if next_offset >= end_offset {
9758 return Ok(());
9759 }
9760
9761 while _next_ordinal_to_read < 1 {
9763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9764 _next_ordinal_to_read += 1;
9765 next_offset += envelope_size;
9766 }
9767
9768 let next_out_of_line = decoder.next_out_of_line();
9769 let handles_before = decoder.remaining_handles();
9770 if let Some((inlined, num_bytes, num_handles)) =
9771 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9772 {
9773 let member_inline_size =
9774 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
9775 decoder.context,
9776 );
9777 if inlined != (member_inline_size <= 4) {
9778 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9779 }
9780 let inner_offset;
9781 let mut inner_depth = depth.clone();
9782 if inlined {
9783 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9784 inner_offset = next_offset;
9785 } else {
9786 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9787 inner_depth.increment()?;
9788 }
9789 let val_ref = self
9790 .selected_bssid
9791 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
9792 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
9793 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9794 {
9795 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9796 }
9797 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9798 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9799 }
9800 }
9801
9802 next_offset += envelope_size;
9803 _next_ordinal_to_read += 1;
9804 if next_offset >= end_offset {
9805 return Ok(());
9806 }
9807
9808 while _next_ordinal_to_read < 2 {
9810 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9811 _next_ordinal_to_read += 1;
9812 next_offset += envelope_size;
9813 }
9814
9815 let next_out_of_line = decoder.next_out_of_line();
9816 let handles_before = decoder.remaining_handles();
9817 if let Some((inlined, num_bytes, num_handles)) =
9818 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9819 {
9820 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9821 if inlined != (member_inline_size <= 4) {
9822 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9823 }
9824 let inner_offset;
9825 let mut inner_depth = depth.clone();
9826 if inlined {
9827 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9828 inner_offset = next_offset;
9829 } else {
9830 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9831 inner_depth.increment()?;
9832 }
9833 let val_ref = self.status_code.get_or_insert_with(|| {
9834 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
9835 });
9836 fidl::decode!(
9837 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
9838 D,
9839 val_ref,
9840 decoder,
9841 inner_offset,
9842 inner_depth
9843 )?;
9844 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9845 {
9846 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9847 }
9848 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9849 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9850 }
9851 }
9852
9853 next_offset += envelope_size;
9854 _next_ordinal_to_read += 1;
9855 if next_offset >= end_offset {
9856 return Ok(());
9857 }
9858
9859 while _next_ordinal_to_read < 3 {
9861 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9862 _next_ordinal_to_read += 1;
9863 next_offset += envelope_size;
9864 }
9865
9866 let next_out_of_line = decoder.next_out_of_line();
9867 let handles_before = decoder.remaining_handles();
9868 if let Some((inlined, num_bytes, num_handles)) =
9869 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9870 {
9871 let member_inline_size =
9872 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9873 if inlined != (member_inline_size <= 4) {
9874 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9875 }
9876 let inner_offset;
9877 let mut inner_depth = depth.clone();
9878 if inlined {
9879 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9880 inner_offset = next_offset;
9881 } else {
9882 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9883 inner_depth.increment()?;
9884 }
9885 let val_ref = self
9886 .original_association_maintained
9887 .get_or_insert_with(|| fidl::new_empty!(bool, D));
9888 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9889 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9890 {
9891 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9892 }
9893 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9894 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9895 }
9896 }
9897
9898 next_offset += envelope_size;
9899 _next_ordinal_to_read += 1;
9900 if next_offset >= end_offset {
9901 return Ok(());
9902 }
9903
9904 while _next_ordinal_to_read < 4 {
9906 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9907 _next_ordinal_to_read += 1;
9908 next_offset += envelope_size;
9909 }
9910
9911 let next_out_of_line = decoder.next_out_of_line();
9912 let handles_before = decoder.remaining_handles();
9913 if let Some((inlined, num_bytes, num_handles)) =
9914 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9915 {
9916 let member_inline_size =
9917 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9918 if inlined != (member_inline_size <= 4) {
9919 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9920 }
9921 let inner_offset;
9922 let mut inner_depth = depth.clone();
9923 if inlined {
9924 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9925 inner_offset = next_offset;
9926 } else {
9927 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9928 inner_depth.increment()?;
9929 }
9930 let val_ref =
9931 self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
9932 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9933 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9934 {
9935 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9936 }
9937 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9938 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9939 }
9940 }
9941
9942 next_offset += envelope_size;
9943 _next_ordinal_to_read += 1;
9944 if next_offset >= end_offset {
9945 return Ok(());
9946 }
9947
9948 while _next_ordinal_to_read < 5 {
9950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9951 _next_ordinal_to_read += 1;
9952 next_offset += envelope_size;
9953 }
9954
9955 let next_out_of_line = decoder.next_out_of_line();
9956 let handles_before = decoder.remaining_handles();
9957 if let Some((inlined, num_bytes, num_handles)) =
9958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9959 {
9960 let member_inline_size =
9961 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9962 if inlined != (member_inline_size <= 4) {
9963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9964 }
9965 let inner_offset;
9966 let mut inner_depth = depth.clone();
9967 if inlined {
9968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9969 inner_offset = next_offset;
9970 } else {
9971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9972 inner_depth.increment()?;
9973 }
9974 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9975 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9976 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9977 {
9978 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9979 }
9980 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9981 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9982 }
9983 }
9984
9985 next_offset += envelope_size;
9986 _next_ordinal_to_read += 1;
9987 if next_offset >= end_offset {
9988 return Ok(());
9989 }
9990
9991 while _next_ordinal_to_read < 6 {
9993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9994 _next_ordinal_to_read += 1;
9995 next_offset += envelope_size;
9996 }
9997
9998 let next_out_of_line = decoder.next_out_of_line();
9999 let handles_before = decoder.remaining_handles();
10000 if let Some((inlined, num_bytes, num_handles)) =
10001 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10002 {
10003 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10004 if inlined != (member_inline_size <= 4) {
10005 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10006 }
10007 let inner_offset;
10008 let mut inner_depth = depth.clone();
10009 if inlined {
10010 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10011 inner_offset = next_offset;
10012 } else {
10013 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10014 inner_depth.increment()?;
10015 }
10016 let val_ref = self.association_ies.get_or_insert_with(|| {
10017 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10018 });
10019 fidl::decode!(
10020 fidl::encoding::UnboundedVector<u8>,
10021 D,
10022 val_ref,
10023 decoder,
10024 inner_offset,
10025 inner_depth
10026 )?;
10027 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10028 {
10029 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10030 }
10031 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10032 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10033 }
10034 }
10035
10036 next_offset += envelope_size;
10037
10038 while next_offset < end_offset {
10040 _next_ordinal_to_read += 1;
10041 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10042 next_offset += envelope_size;
10043 }
10044
10045 Ok(())
10046 }
10047 }
10048
10049 impl WlanFullmacImplIfcRoamResultIndRequest {
10050 #[inline(always)]
10051 fn max_ordinal_present(&self) -> u64 {
10052 if let Some(_) = self.association_ies {
10053 return 6;
10054 }
10055 if let Some(_) = self.association_id {
10056 return 5;
10057 }
10058 if let Some(_) = self.target_bss_authenticated {
10059 return 4;
10060 }
10061 if let Some(_) = self.original_association_maintained {
10062 return 3;
10063 }
10064 if let Some(_) = self.status_code {
10065 return 2;
10066 }
10067 if let Some(_) = self.selected_bssid {
10068 return 1;
10069 }
10070 0
10071 }
10072 }
10073
10074 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10075 type Borrowed<'a> = &'a Self;
10076 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10077 value
10078 }
10079 }
10080
10081 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10082 type Owned = Self;
10083
10084 #[inline(always)]
10085 fn inline_align(_context: fidl::encoding::Context) -> usize {
10086 8
10087 }
10088
10089 #[inline(always)]
10090 fn inline_size(_context: fidl::encoding::Context) -> usize {
10091 16
10092 }
10093 }
10094
10095 unsafe impl<D: fidl::encoding::ResourceDialect>
10096 fidl::encoding::Encode<WlanFullmacImplIfcRoamResultIndRequest, D>
10097 for &WlanFullmacImplIfcRoamResultIndRequest
10098 {
10099 unsafe fn encode(
10100 self,
10101 encoder: &mut fidl::encoding::Encoder<'_, D>,
10102 offset: usize,
10103 mut depth: fidl::encoding::Depth,
10104 ) -> fidl::Result<()> {
10105 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamResultIndRequest>(offset);
10106 let max_ordinal: u64 = self.max_ordinal_present();
10108 encoder.write_num(max_ordinal, offset);
10109 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10110 if max_ordinal == 0 {
10112 return Ok(());
10113 }
10114 depth.increment()?;
10115 let envelope_size = 8;
10116 let bytes_len = max_ordinal as usize * envelope_size;
10117 #[allow(unused_variables)]
10118 let offset = encoder.out_of_line_offset(bytes_len);
10119 let mut _prev_end_offset: usize = 0;
10120 if 1 > max_ordinal {
10121 return Ok(());
10122 }
10123
10124 let cur_offset: usize = (1 - 1) * envelope_size;
10127
10128 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10130
10131 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10136 self.selected_bssid
10137 .as_ref()
10138 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10139 encoder,
10140 offset + cur_offset,
10141 depth,
10142 )?;
10143
10144 _prev_end_offset = cur_offset + envelope_size;
10145 if 2 > max_ordinal {
10146 return Ok(());
10147 }
10148
10149 let cur_offset: usize = (2 - 1) * envelope_size;
10152
10153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10155
10156 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
10161 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
10162 encoder, offset + cur_offset, depth
10163 )?;
10164
10165 _prev_end_offset = cur_offset + envelope_size;
10166 if 3 > max_ordinal {
10167 return Ok(());
10168 }
10169
10170 let cur_offset: usize = (3 - 1) * envelope_size;
10173
10174 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10176
10177 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10182 self.original_association_maintained
10183 .as_ref()
10184 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10185 encoder,
10186 offset + cur_offset,
10187 depth,
10188 )?;
10189
10190 _prev_end_offset = cur_offset + envelope_size;
10191 if 4 > max_ordinal {
10192 return Ok(());
10193 }
10194
10195 let cur_offset: usize = (4 - 1) * envelope_size;
10198
10199 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10201
10202 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10207 self.target_bss_authenticated
10208 .as_ref()
10209 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10210 encoder,
10211 offset + cur_offset,
10212 depth,
10213 )?;
10214
10215 _prev_end_offset = cur_offset + envelope_size;
10216 if 5 > max_ordinal {
10217 return Ok(());
10218 }
10219
10220 let cur_offset: usize = (5 - 1) * envelope_size;
10223
10224 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10226
10227 fidl::encoding::encode_in_envelope_optional::<u16, D>(
10232 self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10233 encoder,
10234 offset + cur_offset,
10235 depth,
10236 )?;
10237
10238 _prev_end_offset = cur_offset + envelope_size;
10239 if 6 > max_ordinal {
10240 return Ok(());
10241 }
10242
10243 let cur_offset: usize = (6 - 1) * envelope_size;
10246
10247 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10249
10250 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10255 self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10256 encoder, offset + cur_offset, depth
10257 )?;
10258
10259 _prev_end_offset = cur_offset + envelope_size;
10260
10261 Ok(())
10262 }
10263 }
10264
10265 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10266 for WlanFullmacImplIfcRoamResultIndRequest
10267 {
10268 #[inline(always)]
10269 fn new_empty() -> Self {
10270 Self::default()
10271 }
10272
10273 unsafe fn decode(
10274 &mut self,
10275 decoder: &mut fidl::encoding::Decoder<'_, D>,
10276 offset: usize,
10277 mut depth: fidl::encoding::Depth,
10278 ) -> fidl::Result<()> {
10279 decoder.debug_check_bounds::<Self>(offset);
10280 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10281 None => return Err(fidl::Error::NotNullable),
10282 Some(len) => len,
10283 };
10284 if len == 0 {
10286 return Ok(());
10287 };
10288 depth.increment()?;
10289 let envelope_size = 8;
10290 let bytes_len = len * envelope_size;
10291 let offset = decoder.out_of_line_offset(bytes_len)?;
10292 let mut _next_ordinal_to_read = 0;
10294 let mut next_offset = offset;
10295 let end_offset = offset + bytes_len;
10296 _next_ordinal_to_read += 1;
10297 if next_offset >= end_offset {
10298 return Ok(());
10299 }
10300
10301 while _next_ordinal_to_read < 1 {
10303 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10304 _next_ordinal_to_read += 1;
10305 next_offset += envelope_size;
10306 }
10307
10308 let next_out_of_line = decoder.next_out_of_line();
10309 let handles_before = decoder.remaining_handles();
10310 if let Some((inlined, num_bytes, num_handles)) =
10311 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10312 {
10313 let member_inline_size =
10314 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10315 decoder.context,
10316 );
10317 if inlined != (member_inline_size <= 4) {
10318 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10319 }
10320 let inner_offset;
10321 let mut inner_depth = depth.clone();
10322 if inlined {
10323 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10324 inner_offset = next_offset;
10325 } else {
10326 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10327 inner_depth.increment()?;
10328 }
10329 let val_ref = self
10330 .selected_bssid
10331 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10332 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
10333 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10334 {
10335 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10336 }
10337 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10338 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10339 }
10340 }
10341
10342 next_offset += envelope_size;
10343 _next_ordinal_to_read += 1;
10344 if next_offset >= end_offset {
10345 return Ok(());
10346 }
10347
10348 while _next_ordinal_to_read < 2 {
10350 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10351 _next_ordinal_to_read += 1;
10352 next_offset += envelope_size;
10353 }
10354
10355 let next_out_of_line = decoder.next_out_of_line();
10356 let handles_before = decoder.remaining_handles();
10357 if let Some((inlined, num_bytes, num_handles)) =
10358 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10359 {
10360 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10361 if inlined != (member_inline_size <= 4) {
10362 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10363 }
10364 let inner_offset;
10365 let mut inner_depth = depth.clone();
10366 if inlined {
10367 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10368 inner_offset = next_offset;
10369 } else {
10370 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10371 inner_depth.increment()?;
10372 }
10373 let val_ref = self.status_code.get_or_insert_with(|| {
10374 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
10375 });
10376 fidl::decode!(
10377 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
10378 D,
10379 val_ref,
10380 decoder,
10381 inner_offset,
10382 inner_depth
10383 )?;
10384 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10385 {
10386 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10387 }
10388 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10389 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10390 }
10391 }
10392
10393 next_offset += envelope_size;
10394 _next_ordinal_to_read += 1;
10395 if next_offset >= end_offset {
10396 return Ok(());
10397 }
10398
10399 while _next_ordinal_to_read < 3 {
10401 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10402 _next_ordinal_to_read += 1;
10403 next_offset += envelope_size;
10404 }
10405
10406 let next_out_of_line = decoder.next_out_of_line();
10407 let handles_before = decoder.remaining_handles();
10408 if let Some((inlined, num_bytes, num_handles)) =
10409 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10410 {
10411 let member_inline_size =
10412 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10413 if inlined != (member_inline_size <= 4) {
10414 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10415 }
10416 let inner_offset;
10417 let mut inner_depth = depth.clone();
10418 if inlined {
10419 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10420 inner_offset = next_offset;
10421 } else {
10422 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10423 inner_depth.increment()?;
10424 }
10425 let val_ref = self
10426 .original_association_maintained
10427 .get_or_insert_with(|| fidl::new_empty!(bool, D));
10428 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10430 {
10431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10432 }
10433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10435 }
10436 }
10437
10438 next_offset += envelope_size;
10439 _next_ordinal_to_read += 1;
10440 if next_offset >= end_offset {
10441 return Ok(());
10442 }
10443
10444 while _next_ordinal_to_read < 4 {
10446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10447 _next_ordinal_to_read += 1;
10448 next_offset += envelope_size;
10449 }
10450
10451 let next_out_of_line = decoder.next_out_of_line();
10452 let handles_before = decoder.remaining_handles();
10453 if let Some((inlined, num_bytes, num_handles)) =
10454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10455 {
10456 let member_inline_size =
10457 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10458 if inlined != (member_inline_size <= 4) {
10459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10460 }
10461 let inner_offset;
10462 let mut inner_depth = depth.clone();
10463 if inlined {
10464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10465 inner_offset = next_offset;
10466 } else {
10467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10468 inner_depth.increment()?;
10469 }
10470 let val_ref =
10471 self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
10472 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10473 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10474 {
10475 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10476 }
10477 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10478 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10479 }
10480 }
10481
10482 next_offset += envelope_size;
10483 _next_ordinal_to_read += 1;
10484 if next_offset >= end_offset {
10485 return Ok(());
10486 }
10487
10488 while _next_ordinal_to_read < 5 {
10490 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10491 _next_ordinal_to_read += 1;
10492 next_offset += envelope_size;
10493 }
10494
10495 let next_out_of_line = decoder.next_out_of_line();
10496 let handles_before = decoder.remaining_handles();
10497 if let Some((inlined, num_bytes, num_handles)) =
10498 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10499 {
10500 let member_inline_size =
10501 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10502 if inlined != (member_inline_size <= 4) {
10503 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10504 }
10505 let inner_offset;
10506 let mut inner_depth = depth.clone();
10507 if inlined {
10508 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10509 inner_offset = next_offset;
10510 } else {
10511 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10512 inner_depth.increment()?;
10513 }
10514 let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10515 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10516 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10517 {
10518 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10519 }
10520 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10521 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10522 }
10523 }
10524
10525 next_offset += envelope_size;
10526 _next_ordinal_to_read += 1;
10527 if next_offset >= end_offset {
10528 return Ok(());
10529 }
10530
10531 while _next_ordinal_to_read < 6 {
10533 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10534 _next_ordinal_to_read += 1;
10535 next_offset += envelope_size;
10536 }
10537
10538 let next_out_of_line = decoder.next_out_of_line();
10539 let handles_before = decoder.remaining_handles();
10540 if let Some((inlined, num_bytes, num_handles)) =
10541 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10542 {
10543 let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10544 if inlined != (member_inline_size <= 4) {
10545 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10546 }
10547 let inner_offset;
10548 let mut inner_depth = depth.clone();
10549 if inlined {
10550 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10551 inner_offset = next_offset;
10552 } else {
10553 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10554 inner_depth.increment()?;
10555 }
10556 let val_ref = self.association_ies.get_or_insert_with(|| {
10557 fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10558 });
10559 fidl::decode!(
10560 fidl::encoding::UnboundedVector<u8>,
10561 D,
10562 val_ref,
10563 decoder,
10564 inner_offset,
10565 inner_depth
10566 )?;
10567 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10568 {
10569 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10570 }
10571 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10572 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10573 }
10574 }
10575
10576 next_offset += envelope_size;
10577
10578 while next_offset < end_offset {
10580 _next_ordinal_to_read += 1;
10581 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10582 next_offset += envelope_size;
10583 }
10584
10585 Ok(())
10586 }
10587 }
10588
10589 impl WlanFullmacImplIfcRoamStartIndRequest {
10590 #[inline(always)]
10591 fn max_ordinal_present(&self) -> u64 {
10592 if let Some(_) = self.original_association_maintained {
10593 return 3;
10594 }
10595 if let Some(_) = self.selected_bss {
10596 return 2;
10597 }
10598 if let Some(_) = self.selected_bssid {
10599 return 1;
10600 }
10601 0
10602 }
10603 }
10604
10605 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10606 type Borrowed<'a> = &'a Self;
10607 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10608 value
10609 }
10610 }
10611
10612 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10613 type Owned = Self;
10614
10615 #[inline(always)]
10616 fn inline_align(_context: fidl::encoding::Context) -> usize {
10617 8
10618 }
10619
10620 #[inline(always)]
10621 fn inline_size(_context: fidl::encoding::Context) -> usize {
10622 16
10623 }
10624 }
10625
10626 unsafe impl<D: fidl::encoding::ResourceDialect>
10627 fidl::encoding::Encode<WlanFullmacImplIfcRoamStartIndRequest, D>
10628 for &WlanFullmacImplIfcRoamStartIndRequest
10629 {
10630 unsafe fn encode(
10631 self,
10632 encoder: &mut fidl::encoding::Encoder<'_, D>,
10633 offset: usize,
10634 mut depth: fidl::encoding::Depth,
10635 ) -> fidl::Result<()> {
10636 encoder.debug_check_bounds::<WlanFullmacImplIfcRoamStartIndRequest>(offset);
10637 let max_ordinal: u64 = self.max_ordinal_present();
10639 encoder.write_num(max_ordinal, offset);
10640 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10641 if max_ordinal == 0 {
10643 return Ok(());
10644 }
10645 depth.increment()?;
10646 let envelope_size = 8;
10647 let bytes_len = max_ordinal as usize * envelope_size;
10648 #[allow(unused_variables)]
10649 let offset = encoder.out_of_line_offset(bytes_len);
10650 let mut _prev_end_offset: usize = 0;
10651 if 1 > max_ordinal {
10652 return Ok(());
10653 }
10654
10655 let cur_offset: usize = (1 - 1) * envelope_size;
10658
10659 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10661
10662 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10667 self.selected_bssid
10668 .as_ref()
10669 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10670 encoder,
10671 offset + cur_offset,
10672 depth,
10673 )?;
10674
10675 _prev_end_offset = cur_offset + envelope_size;
10676 if 2 > max_ordinal {
10677 return Ok(());
10678 }
10679
10680 let cur_offset: usize = (2 - 1) * envelope_size;
10683
10684 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10686
10687 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
10692 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
10693 encoder, offset + cur_offset, depth
10694 )?;
10695
10696 _prev_end_offset = cur_offset + envelope_size;
10697 if 3 > max_ordinal {
10698 return Ok(());
10699 }
10700
10701 let cur_offset: usize = (3 - 1) * envelope_size;
10704
10705 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10707
10708 fidl::encoding::encode_in_envelope_optional::<bool, D>(
10713 self.original_association_maintained
10714 .as_ref()
10715 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10716 encoder,
10717 offset + cur_offset,
10718 depth,
10719 )?;
10720
10721 _prev_end_offset = cur_offset + envelope_size;
10722
10723 Ok(())
10724 }
10725 }
10726
10727 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10728 for WlanFullmacImplIfcRoamStartIndRequest
10729 {
10730 #[inline(always)]
10731 fn new_empty() -> Self {
10732 Self::default()
10733 }
10734
10735 unsafe fn decode(
10736 &mut self,
10737 decoder: &mut fidl::encoding::Decoder<'_, D>,
10738 offset: usize,
10739 mut depth: fidl::encoding::Depth,
10740 ) -> fidl::Result<()> {
10741 decoder.debug_check_bounds::<Self>(offset);
10742 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10743 None => return Err(fidl::Error::NotNullable),
10744 Some(len) => len,
10745 };
10746 if len == 0 {
10748 return Ok(());
10749 };
10750 depth.increment()?;
10751 let envelope_size = 8;
10752 let bytes_len = len * envelope_size;
10753 let offset = decoder.out_of_line_offset(bytes_len)?;
10754 let mut _next_ordinal_to_read = 0;
10756 let mut next_offset = offset;
10757 let end_offset = offset + bytes_len;
10758 _next_ordinal_to_read += 1;
10759 if next_offset >= end_offset {
10760 return Ok(());
10761 }
10762
10763 while _next_ordinal_to_read < 1 {
10765 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10766 _next_ordinal_to_read += 1;
10767 next_offset += envelope_size;
10768 }
10769
10770 let next_out_of_line = decoder.next_out_of_line();
10771 let handles_before = decoder.remaining_handles();
10772 if let Some((inlined, num_bytes, num_handles)) =
10773 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10774 {
10775 let member_inline_size =
10776 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10777 decoder.context,
10778 );
10779 if inlined != (member_inline_size <= 4) {
10780 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10781 }
10782 let inner_offset;
10783 let mut inner_depth = depth.clone();
10784 if inlined {
10785 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10786 inner_offset = next_offset;
10787 } else {
10788 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10789 inner_depth.increment()?;
10790 }
10791 let val_ref = self
10792 .selected_bssid
10793 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10794 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
10795 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10796 {
10797 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10798 }
10799 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10800 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10801 }
10802 }
10803
10804 next_offset += envelope_size;
10805 _next_ordinal_to_read += 1;
10806 if next_offset >= end_offset {
10807 return Ok(());
10808 }
10809
10810 while _next_ordinal_to_read < 2 {
10812 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10813 _next_ordinal_to_read += 1;
10814 next_offset += envelope_size;
10815 }
10816
10817 let next_out_of_line = decoder.next_out_of_line();
10818 let handles_before = decoder.remaining_handles();
10819 if let Some((inlined, num_bytes, num_handles)) =
10820 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10821 {
10822 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10823 if inlined != (member_inline_size <= 4) {
10824 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10825 }
10826 let inner_offset;
10827 let mut inner_depth = depth.clone();
10828 if inlined {
10829 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10830 inner_offset = next_offset;
10831 } else {
10832 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10833 inner_depth.increment()?;
10834 }
10835 let val_ref = self.selected_bss.get_or_insert_with(|| {
10836 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
10837 });
10838 fidl::decode!(
10839 fidl_fuchsia_wlan_common__common::BssDescription,
10840 D,
10841 val_ref,
10842 decoder,
10843 inner_offset,
10844 inner_depth
10845 )?;
10846 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10847 {
10848 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10849 }
10850 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10851 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10852 }
10853 }
10854
10855 next_offset += envelope_size;
10856 _next_ordinal_to_read += 1;
10857 if next_offset >= end_offset {
10858 return Ok(());
10859 }
10860
10861 while _next_ordinal_to_read < 3 {
10863 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10864 _next_ordinal_to_read += 1;
10865 next_offset += envelope_size;
10866 }
10867
10868 let next_out_of_line = decoder.next_out_of_line();
10869 let handles_before = decoder.remaining_handles();
10870 if let Some((inlined, num_bytes, num_handles)) =
10871 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10872 {
10873 let member_inline_size =
10874 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10875 if inlined != (member_inline_size <= 4) {
10876 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10877 }
10878 let inner_offset;
10879 let mut inner_depth = depth.clone();
10880 if inlined {
10881 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10882 inner_offset = next_offset;
10883 } else {
10884 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10885 inner_depth.increment()?;
10886 }
10887 let val_ref = self
10888 .original_association_maintained
10889 .get_or_insert_with(|| fidl::new_empty!(bool, D));
10890 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10891 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10892 {
10893 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10894 }
10895 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10896 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10897 }
10898 }
10899
10900 next_offset += envelope_size;
10901
10902 while next_offset < end_offset {
10904 _next_ordinal_to_read += 1;
10905 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10906 next_offset += envelope_size;
10907 }
10908
10909 Ok(())
10910 }
10911 }
10912
10913 impl WlanFullmacImplIfcSaeHandshakeIndRequest {
10914 #[inline(always)]
10915 fn max_ordinal_present(&self) -> u64 {
10916 if let Some(_) = self.peer_sta_address {
10917 return 1;
10918 }
10919 0
10920 }
10921 }
10922
10923 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10924 type Borrowed<'a> = &'a Self;
10925 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10926 value
10927 }
10928 }
10929
10930 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10931 type Owned = Self;
10932
10933 #[inline(always)]
10934 fn inline_align(_context: fidl::encoding::Context) -> usize {
10935 8
10936 }
10937
10938 #[inline(always)]
10939 fn inline_size(_context: fidl::encoding::Context) -> usize {
10940 16
10941 }
10942 }
10943
10944 unsafe impl<D: fidl::encoding::ResourceDialect>
10945 fidl::encoding::Encode<WlanFullmacImplIfcSaeHandshakeIndRequest, D>
10946 for &WlanFullmacImplIfcSaeHandshakeIndRequest
10947 {
10948 unsafe fn encode(
10949 self,
10950 encoder: &mut fidl::encoding::Encoder<'_, D>,
10951 offset: usize,
10952 mut depth: fidl::encoding::Depth,
10953 ) -> fidl::Result<()> {
10954 encoder.debug_check_bounds::<WlanFullmacImplIfcSaeHandshakeIndRequest>(offset);
10955 let max_ordinal: u64 = self.max_ordinal_present();
10957 encoder.write_num(max_ordinal, offset);
10958 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10959 if max_ordinal == 0 {
10961 return Ok(());
10962 }
10963 depth.increment()?;
10964 let envelope_size = 8;
10965 let bytes_len = max_ordinal as usize * envelope_size;
10966 #[allow(unused_variables)]
10967 let offset = encoder.out_of_line_offset(bytes_len);
10968 let mut _prev_end_offset: usize = 0;
10969 if 1 > max_ordinal {
10970 return Ok(());
10971 }
10972
10973 let cur_offset: usize = (1 - 1) * envelope_size;
10976
10977 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10979
10980 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10985 self.peer_sta_address
10986 .as_ref()
10987 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10988 encoder,
10989 offset + cur_offset,
10990 depth,
10991 )?;
10992
10993 _prev_end_offset = cur_offset + envelope_size;
10994
10995 Ok(())
10996 }
10997 }
10998
10999 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11000 for WlanFullmacImplIfcSaeHandshakeIndRequest
11001 {
11002 #[inline(always)]
11003 fn new_empty() -> Self {
11004 Self::default()
11005 }
11006
11007 unsafe fn decode(
11008 &mut self,
11009 decoder: &mut fidl::encoding::Decoder<'_, D>,
11010 offset: usize,
11011 mut depth: fidl::encoding::Depth,
11012 ) -> fidl::Result<()> {
11013 decoder.debug_check_bounds::<Self>(offset);
11014 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11015 None => return Err(fidl::Error::NotNullable),
11016 Some(len) => len,
11017 };
11018 if len == 0 {
11020 return Ok(());
11021 };
11022 depth.increment()?;
11023 let envelope_size = 8;
11024 let bytes_len = len * envelope_size;
11025 let offset = decoder.out_of_line_offset(bytes_len)?;
11026 let mut _next_ordinal_to_read = 0;
11028 let mut next_offset = offset;
11029 let end_offset = offset + bytes_len;
11030 _next_ordinal_to_read += 1;
11031 if next_offset >= end_offset {
11032 return Ok(());
11033 }
11034
11035 while _next_ordinal_to_read < 1 {
11037 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11038 _next_ordinal_to_read += 1;
11039 next_offset += envelope_size;
11040 }
11041
11042 let next_out_of_line = decoder.next_out_of_line();
11043 let handles_before = decoder.remaining_handles();
11044 if let Some((inlined, num_bytes, num_handles)) =
11045 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11046 {
11047 let member_inline_size =
11048 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11049 decoder.context,
11050 );
11051 if inlined != (member_inline_size <= 4) {
11052 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11053 }
11054 let inner_offset;
11055 let mut inner_depth = depth.clone();
11056 if inlined {
11057 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11058 inner_offset = next_offset;
11059 } else {
11060 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11061 inner_depth.increment()?;
11062 }
11063 let val_ref = self
11064 .peer_sta_address
11065 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11066 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11067 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11068 {
11069 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11070 }
11071 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11072 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11073 }
11074 }
11075
11076 next_offset += envelope_size;
11077
11078 while next_offset < end_offset {
11080 _next_ordinal_to_read += 1;
11081 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11082 next_offset += envelope_size;
11083 }
11084
11085 Ok(())
11086 }
11087 }
11088
11089 impl WlanFullmacImplIfcStartConfRequest {
11090 #[inline(always)]
11091 fn max_ordinal_present(&self) -> u64 {
11092 if let Some(_) = self.result_code {
11093 return 1;
11094 }
11095 0
11096 }
11097 }
11098
11099 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStartConfRequest {
11100 type Borrowed<'a> = &'a Self;
11101 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11102 value
11103 }
11104 }
11105
11106 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStartConfRequest {
11107 type Owned = Self;
11108
11109 #[inline(always)]
11110 fn inline_align(_context: fidl::encoding::Context) -> usize {
11111 8
11112 }
11113
11114 #[inline(always)]
11115 fn inline_size(_context: fidl::encoding::Context) -> usize {
11116 16
11117 }
11118 }
11119
11120 unsafe impl<D: fidl::encoding::ResourceDialect>
11121 fidl::encoding::Encode<WlanFullmacImplIfcStartConfRequest, D>
11122 for &WlanFullmacImplIfcStartConfRequest
11123 {
11124 unsafe fn encode(
11125 self,
11126 encoder: &mut fidl::encoding::Encoder<'_, D>,
11127 offset: usize,
11128 mut depth: fidl::encoding::Depth,
11129 ) -> fidl::Result<()> {
11130 encoder.debug_check_bounds::<WlanFullmacImplIfcStartConfRequest>(offset);
11131 let max_ordinal: u64 = self.max_ordinal_present();
11133 encoder.write_num(max_ordinal, offset);
11134 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11135 if max_ordinal == 0 {
11137 return Ok(());
11138 }
11139 depth.increment()?;
11140 let envelope_size = 8;
11141 let bytes_len = max_ordinal as usize * envelope_size;
11142 #[allow(unused_variables)]
11143 let offset = encoder.out_of_line_offset(bytes_len);
11144 let mut _prev_end_offset: usize = 0;
11145 if 1 > max_ordinal {
11146 return Ok(());
11147 }
11148
11149 let cur_offset: usize = (1 - 1) * envelope_size;
11152
11153 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11155
11156 fidl::encoding::encode_in_envelope_optional::<StartResult, D>(
11161 self.result_code
11162 .as_ref()
11163 .map(<StartResult as fidl::encoding::ValueTypeMarker>::borrow),
11164 encoder,
11165 offset + cur_offset,
11166 depth,
11167 )?;
11168
11169 _prev_end_offset = cur_offset + envelope_size;
11170
11171 Ok(())
11172 }
11173 }
11174
11175 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11176 for WlanFullmacImplIfcStartConfRequest
11177 {
11178 #[inline(always)]
11179 fn new_empty() -> Self {
11180 Self::default()
11181 }
11182
11183 unsafe fn decode(
11184 &mut self,
11185 decoder: &mut fidl::encoding::Decoder<'_, D>,
11186 offset: usize,
11187 mut depth: fidl::encoding::Depth,
11188 ) -> fidl::Result<()> {
11189 decoder.debug_check_bounds::<Self>(offset);
11190 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11191 None => return Err(fidl::Error::NotNullable),
11192 Some(len) => len,
11193 };
11194 if len == 0 {
11196 return Ok(());
11197 };
11198 depth.increment()?;
11199 let envelope_size = 8;
11200 let bytes_len = len * envelope_size;
11201 let offset = decoder.out_of_line_offset(bytes_len)?;
11202 let mut _next_ordinal_to_read = 0;
11204 let mut next_offset = offset;
11205 let end_offset = offset + bytes_len;
11206 _next_ordinal_to_read += 1;
11207 if next_offset >= end_offset {
11208 return Ok(());
11209 }
11210
11211 while _next_ordinal_to_read < 1 {
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 <StartResult 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 =
11238 self.result_code.get_or_insert_with(|| fidl::new_empty!(StartResult, D));
11239 fidl::decode!(StartResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11240 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11241 {
11242 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11243 }
11244 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11245 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11246 }
11247 }
11248
11249 next_offset += envelope_size;
11250
11251 while next_offset < end_offset {
11253 _next_ordinal_to_read += 1;
11254 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11255 next_offset += envelope_size;
11256 }
11257
11258 Ok(())
11259 }
11260 }
11261
11262 impl WlanFullmacImplIfcStopConfRequest {
11263 #[inline(always)]
11264 fn max_ordinal_present(&self) -> u64 {
11265 if let Some(_) = self.result_code {
11266 return 1;
11267 }
11268 0
11269 }
11270 }
11271
11272 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStopConfRequest {
11273 type Borrowed<'a> = &'a Self;
11274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11275 value
11276 }
11277 }
11278
11279 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStopConfRequest {
11280 type Owned = Self;
11281
11282 #[inline(always)]
11283 fn inline_align(_context: fidl::encoding::Context) -> usize {
11284 8
11285 }
11286
11287 #[inline(always)]
11288 fn inline_size(_context: fidl::encoding::Context) -> usize {
11289 16
11290 }
11291 }
11292
11293 unsafe impl<D: fidl::encoding::ResourceDialect>
11294 fidl::encoding::Encode<WlanFullmacImplIfcStopConfRequest, D>
11295 for &WlanFullmacImplIfcStopConfRequest
11296 {
11297 unsafe fn encode(
11298 self,
11299 encoder: &mut fidl::encoding::Encoder<'_, D>,
11300 offset: usize,
11301 mut depth: fidl::encoding::Depth,
11302 ) -> fidl::Result<()> {
11303 encoder.debug_check_bounds::<WlanFullmacImplIfcStopConfRequest>(offset);
11304 let max_ordinal: u64 = self.max_ordinal_present();
11306 encoder.write_num(max_ordinal, offset);
11307 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11308 if max_ordinal == 0 {
11310 return Ok(());
11311 }
11312 depth.increment()?;
11313 let envelope_size = 8;
11314 let bytes_len = max_ordinal as usize * envelope_size;
11315 #[allow(unused_variables)]
11316 let offset = encoder.out_of_line_offset(bytes_len);
11317 let mut _prev_end_offset: usize = 0;
11318 if 1 > max_ordinal {
11319 return Ok(());
11320 }
11321
11322 let cur_offset: usize = (1 - 1) * envelope_size;
11325
11326 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11328
11329 fidl::encoding::encode_in_envelope_optional::<StopResult, D>(
11334 self.result_code
11335 .as_ref()
11336 .map(<StopResult as fidl::encoding::ValueTypeMarker>::borrow),
11337 encoder,
11338 offset + cur_offset,
11339 depth,
11340 )?;
11341
11342 _prev_end_offset = cur_offset + envelope_size;
11343
11344 Ok(())
11345 }
11346 }
11347
11348 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11349 for WlanFullmacImplIfcStopConfRequest
11350 {
11351 #[inline(always)]
11352 fn new_empty() -> Self {
11353 Self::default()
11354 }
11355
11356 unsafe fn decode(
11357 &mut self,
11358 decoder: &mut fidl::encoding::Decoder<'_, D>,
11359 offset: usize,
11360 mut depth: fidl::encoding::Depth,
11361 ) -> fidl::Result<()> {
11362 decoder.debug_check_bounds::<Self>(offset);
11363 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11364 None => return Err(fidl::Error::NotNullable),
11365 Some(len) => len,
11366 };
11367 if len == 0 {
11369 return Ok(());
11370 };
11371 depth.increment()?;
11372 let envelope_size = 8;
11373 let bytes_len = len * envelope_size;
11374 let offset = decoder.out_of_line_offset(bytes_len)?;
11375 let mut _next_ordinal_to_read = 0;
11377 let mut next_offset = offset;
11378 let end_offset = offset + bytes_len;
11379 _next_ordinal_to_read += 1;
11380 if next_offset >= end_offset {
11381 return Ok(());
11382 }
11383
11384 while _next_ordinal_to_read < 1 {
11386 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11387 _next_ordinal_to_read += 1;
11388 next_offset += envelope_size;
11389 }
11390
11391 let next_out_of_line = decoder.next_out_of_line();
11392 let handles_before = decoder.remaining_handles();
11393 if let Some((inlined, num_bytes, num_handles)) =
11394 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11395 {
11396 let member_inline_size =
11397 <StopResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11398 if inlined != (member_inline_size <= 4) {
11399 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11400 }
11401 let inner_offset;
11402 let mut inner_depth = depth.clone();
11403 if inlined {
11404 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11405 inner_offset = next_offset;
11406 } else {
11407 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11408 inner_depth.increment()?;
11409 }
11410 let val_ref =
11411 self.result_code.get_or_insert_with(|| fidl::new_empty!(StopResult, D));
11412 fidl::decode!(StopResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11413 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11414 {
11415 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11416 }
11417 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11418 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11419 }
11420 }
11421
11422 next_offset += envelope_size;
11423
11424 while next_offset < end_offset {
11426 _next_ordinal_to_read += 1;
11427 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11428 next_offset += envelope_size;
11429 }
11430
11431 Ok(())
11432 }
11433 }
11434
11435 impl WlanFullmacImplOnLinkStateChangedRequest {
11436 #[inline(always)]
11437 fn max_ordinal_present(&self) -> u64 {
11438 if let Some(_) = self.online {
11439 return 1;
11440 }
11441 0
11442 }
11443 }
11444
11445 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11446 type Borrowed<'a> = &'a Self;
11447 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11448 value
11449 }
11450 }
11451
11452 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11453 type Owned = Self;
11454
11455 #[inline(always)]
11456 fn inline_align(_context: fidl::encoding::Context) -> usize {
11457 8
11458 }
11459
11460 #[inline(always)]
11461 fn inline_size(_context: fidl::encoding::Context) -> usize {
11462 16
11463 }
11464 }
11465
11466 unsafe impl<D: fidl::encoding::ResourceDialect>
11467 fidl::encoding::Encode<WlanFullmacImplOnLinkStateChangedRequest, D>
11468 for &WlanFullmacImplOnLinkStateChangedRequest
11469 {
11470 unsafe fn encode(
11471 self,
11472 encoder: &mut fidl::encoding::Encoder<'_, D>,
11473 offset: usize,
11474 mut depth: fidl::encoding::Depth,
11475 ) -> fidl::Result<()> {
11476 encoder.debug_check_bounds::<WlanFullmacImplOnLinkStateChangedRequest>(offset);
11477 let max_ordinal: u64 = self.max_ordinal_present();
11479 encoder.write_num(max_ordinal, offset);
11480 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11481 if max_ordinal == 0 {
11483 return Ok(());
11484 }
11485 depth.increment()?;
11486 let envelope_size = 8;
11487 let bytes_len = max_ordinal as usize * envelope_size;
11488 #[allow(unused_variables)]
11489 let offset = encoder.out_of_line_offset(bytes_len);
11490 let mut _prev_end_offset: usize = 0;
11491 if 1 > max_ordinal {
11492 return Ok(());
11493 }
11494
11495 let cur_offset: usize = (1 - 1) * envelope_size;
11498
11499 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11501
11502 fidl::encoding::encode_in_envelope_optional::<bool, D>(
11507 self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11508 encoder,
11509 offset + cur_offset,
11510 depth,
11511 )?;
11512
11513 _prev_end_offset = cur_offset + envelope_size;
11514
11515 Ok(())
11516 }
11517 }
11518
11519 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11520 for WlanFullmacImplOnLinkStateChangedRequest
11521 {
11522 #[inline(always)]
11523 fn new_empty() -> Self {
11524 Self::default()
11525 }
11526
11527 unsafe fn decode(
11528 &mut self,
11529 decoder: &mut fidl::encoding::Decoder<'_, D>,
11530 offset: usize,
11531 mut depth: fidl::encoding::Depth,
11532 ) -> fidl::Result<()> {
11533 decoder.debug_check_bounds::<Self>(offset);
11534 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11535 None => return Err(fidl::Error::NotNullable),
11536 Some(len) => len,
11537 };
11538 if len == 0 {
11540 return Ok(());
11541 };
11542 depth.increment()?;
11543 let envelope_size = 8;
11544 let bytes_len = len * envelope_size;
11545 let offset = decoder.out_of_line_offset(bytes_len)?;
11546 let mut _next_ordinal_to_read = 0;
11548 let mut next_offset = offset;
11549 let end_offset = offset + bytes_len;
11550 _next_ordinal_to_read += 1;
11551 if next_offset >= end_offset {
11552 return Ok(());
11553 }
11554
11555 while _next_ordinal_to_read < 1 {
11557 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11558 _next_ordinal_to_read += 1;
11559 next_offset += envelope_size;
11560 }
11561
11562 let next_out_of_line = decoder.next_out_of_line();
11563 let handles_before = decoder.remaining_handles();
11564 if let Some((inlined, num_bytes, num_handles)) =
11565 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11566 {
11567 let member_inline_size =
11568 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11569 if inlined != (member_inline_size <= 4) {
11570 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11571 }
11572 let inner_offset;
11573 let mut inner_depth = depth.clone();
11574 if inlined {
11575 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11576 inner_offset = next_offset;
11577 } else {
11578 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11579 inner_depth.increment()?;
11580 }
11581 let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
11582 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11583 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11584 {
11585 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11586 }
11587 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11588 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11589 }
11590 }
11591
11592 next_offset += envelope_size;
11593
11594 while next_offset < end_offset {
11596 _next_ordinal_to_read += 1;
11597 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11598 next_offset += envelope_size;
11599 }
11600
11601 Ok(())
11602 }
11603 }
11604
11605 impl WlanFullmacImplReconnectRequest {
11606 #[inline(always)]
11607 fn max_ordinal_present(&self) -> u64 {
11608 if let Some(_) = self.peer_sta_address {
11609 return 1;
11610 }
11611 0
11612 }
11613 }
11614
11615 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplReconnectRequest {
11616 type Borrowed<'a> = &'a Self;
11617 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11618 value
11619 }
11620 }
11621
11622 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplReconnectRequest {
11623 type Owned = Self;
11624
11625 #[inline(always)]
11626 fn inline_align(_context: fidl::encoding::Context) -> usize {
11627 8
11628 }
11629
11630 #[inline(always)]
11631 fn inline_size(_context: fidl::encoding::Context) -> usize {
11632 16
11633 }
11634 }
11635
11636 unsafe impl<D: fidl::encoding::ResourceDialect>
11637 fidl::encoding::Encode<WlanFullmacImplReconnectRequest, D>
11638 for &WlanFullmacImplReconnectRequest
11639 {
11640 unsafe fn encode(
11641 self,
11642 encoder: &mut fidl::encoding::Encoder<'_, D>,
11643 offset: usize,
11644 mut depth: fidl::encoding::Depth,
11645 ) -> fidl::Result<()> {
11646 encoder.debug_check_bounds::<WlanFullmacImplReconnectRequest>(offset);
11647 let max_ordinal: u64 = self.max_ordinal_present();
11649 encoder.write_num(max_ordinal, offset);
11650 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11651 if max_ordinal == 0 {
11653 return Ok(());
11654 }
11655 depth.increment()?;
11656 let envelope_size = 8;
11657 let bytes_len = max_ordinal as usize * envelope_size;
11658 #[allow(unused_variables)]
11659 let offset = encoder.out_of_line_offset(bytes_len);
11660 let mut _prev_end_offset: usize = 0;
11661 if 1 > max_ordinal {
11662 return Ok(());
11663 }
11664
11665 let cur_offset: usize = (1 - 1) * envelope_size;
11668
11669 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11671
11672 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11677 self.peer_sta_address
11678 .as_ref()
11679 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11680 encoder,
11681 offset + cur_offset,
11682 depth,
11683 )?;
11684
11685 _prev_end_offset = cur_offset + envelope_size;
11686
11687 Ok(())
11688 }
11689 }
11690
11691 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11692 for WlanFullmacImplReconnectRequest
11693 {
11694 #[inline(always)]
11695 fn new_empty() -> Self {
11696 Self::default()
11697 }
11698
11699 unsafe fn decode(
11700 &mut self,
11701 decoder: &mut fidl::encoding::Decoder<'_, D>,
11702 offset: usize,
11703 mut depth: fidl::encoding::Depth,
11704 ) -> fidl::Result<()> {
11705 decoder.debug_check_bounds::<Self>(offset);
11706 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11707 None => return Err(fidl::Error::NotNullable),
11708 Some(len) => len,
11709 };
11710 if len == 0 {
11712 return Ok(());
11713 };
11714 depth.increment()?;
11715 let envelope_size = 8;
11716 let bytes_len = len * envelope_size;
11717 let offset = decoder.out_of_line_offset(bytes_len)?;
11718 let mut _next_ordinal_to_read = 0;
11720 let mut next_offset = offset;
11721 let end_offset = offset + bytes_len;
11722 _next_ordinal_to_read += 1;
11723 if next_offset >= end_offset {
11724 return Ok(());
11725 }
11726
11727 while _next_ordinal_to_read < 1 {
11729 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11730 _next_ordinal_to_read += 1;
11731 next_offset += envelope_size;
11732 }
11733
11734 let next_out_of_line = decoder.next_out_of_line();
11735 let handles_before = decoder.remaining_handles();
11736 if let Some((inlined, num_bytes, num_handles)) =
11737 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11738 {
11739 let member_inline_size =
11740 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11741 decoder.context,
11742 );
11743 if inlined != (member_inline_size <= 4) {
11744 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11745 }
11746 let inner_offset;
11747 let mut inner_depth = depth.clone();
11748 if inlined {
11749 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11750 inner_offset = next_offset;
11751 } else {
11752 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11753 inner_depth.increment()?;
11754 }
11755 let val_ref = self
11756 .peer_sta_address
11757 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11758 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11759 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11760 {
11761 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11762 }
11763 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11764 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11765 }
11766 }
11767
11768 next_offset += envelope_size;
11769
11770 while next_offset < end_offset {
11772 _next_ordinal_to_read += 1;
11773 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11774 next_offset += envelope_size;
11775 }
11776
11777 Ok(())
11778 }
11779 }
11780
11781 impl WlanFullmacImplRoamRequest {
11782 #[inline(always)]
11783 fn max_ordinal_present(&self) -> u64 {
11784 if let Some(_) = self.selected_bss {
11785 return 1;
11786 }
11787 0
11788 }
11789 }
11790
11791 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplRoamRequest {
11792 type Borrowed<'a> = &'a Self;
11793 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11794 value
11795 }
11796 }
11797
11798 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplRoamRequest {
11799 type Owned = Self;
11800
11801 #[inline(always)]
11802 fn inline_align(_context: fidl::encoding::Context) -> usize {
11803 8
11804 }
11805
11806 #[inline(always)]
11807 fn inline_size(_context: fidl::encoding::Context) -> usize {
11808 16
11809 }
11810 }
11811
11812 unsafe impl<D: fidl::encoding::ResourceDialect>
11813 fidl::encoding::Encode<WlanFullmacImplRoamRequest, D> for &WlanFullmacImplRoamRequest
11814 {
11815 unsafe fn encode(
11816 self,
11817 encoder: &mut fidl::encoding::Encoder<'_, D>,
11818 offset: usize,
11819 mut depth: fidl::encoding::Depth,
11820 ) -> fidl::Result<()> {
11821 encoder.debug_check_bounds::<WlanFullmacImplRoamRequest>(offset);
11822 let max_ordinal: u64 = self.max_ordinal_present();
11824 encoder.write_num(max_ordinal, offset);
11825 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11826 if max_ordinal == 0 {
11828 return Ok(());
11829 }
11830 depth.increment()?;
11831 let envelope_size = 8;
11832 let bytes_len = max_ordinal as usize * envelope_size;
11833 #[allow(unused_variables)]
11834 let offset = encoder.out_of_line_offset(bytes_len);
11835 let mut _prev_end_offset: usize = 0;
11836 if 1 > max_ordinal {
11837 return Ok(());
11838 }
11839
11840 let cur_offset: usize = (1 - 1) * envelope_size;
11843
11844 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11846
11847 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
11852 self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
11853 encoder, offset + cur_offset, depth
11854 )?;
11855
11856 _prev_end_offset = cur_offset + envelope_size;
11857
11858 Ok(())
11859 }
11860 }
11861
11862 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11863 for WlanFullmacImplRoamRequest
11864 {
11865 #[inline(always)]
11866 fn new_empty() -> Self {
11867 Self::default()
11868 }
11869
11870 unsafe fn decode(
11871 &mut self,
11872 decoder: &mut fidl::encoding::Decoder<'_, D>,
11873 offset: usize,
11874 mut depth: fidl::encoding::Depth,
11875 ) -> fidl::Result<()> {
11876 decoder.debug_check_bounds::<Self>(offset);
11877 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11878 None => return Err(fidl::Error::NotNullable),
11879 Some(len) => len,
11880 };
11881 if len == 0 {
11883 return Ok(());
11884 };
11885 depth.increment()?;
11886 let envelope_size = 8;
11887 let bytes_len = len * envelope_size;
11888 let offset = decoder.out_of_line_offset(bytes_len)?;
11889 let mut _next_ordinal_to_read = 0;
11891 let mut next_offset = offset;
11892 let end_offset = offset + bytes_len;
11893 _next_ordinal_to_read += 1;
11894 if next_offset >= end_offset {
11895 return Ok(());
11896 }
11897
11898 while _next_ordinal_to_read < 1 {
11900 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11901 _next_ordinal_to_read += 1;
11902 next_offset += envelope_size;
11903 }
11904
11905 let next_out_of_line = decoder.next_out_of_line();
11906 let handles_before = decoder.remaining_handles();
11907 if let Some((inlined, num_bytes, num_handles)) =
11908 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11909 {
11910 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11911 if inlined != (member_inline_size <= 4) {
11912 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11913 }
11914 let inner_offset;
11915 let mut inner_depth = depth.clone();
11916 if inlined {
11917 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11918 inner_offset = next_offset;
11919 } else {
11920 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11921 inner_depth.increment()?;
11922 }
11923 let val_ref = self.selected_bss.get_or_insert_with(|| {
11924 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
11925 });
11926 fidl::decode!(
11927 fidl_fuchsia_wlan_common__common::BssDescription,
11928 D,
11929 val_ref,
11930 decoder,
11931 inner_offset,
11932 inner_depth
11933 )?;
11934 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11935 {
11936 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11937 }
11938 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11939 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11940 }
11941 }
11942
11943 next_offset += envelope_size;
11944
11945 while next_offset < end_offset {
11947 _next_ordinal_to_read += 1;
11948 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11949 next_offset += envelope_size;
11950 }
11951
11952 Ok(())
11953 }
11954 }
11955
11956 impl WlanFullmacImplSaeHandshakeRespRequest {
11957 #[inline(always)]
11958 fn max_ordinal_present(&self) -> u64 {
11959 if let Some(_) = self.status_code {
11960 return 2;
11961 }
11962 if let Some(_) = self.peer_sta_address {
11963 return 1;
11964 }
11965 0
11966 }
11967 }
11968
11969 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
11970 type Borrowed<'a> = &'a Self;
11971 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11972 value
11973 }
11974 }
11975
11976 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
11977 type Owned = Self;
11978
11979 #[inline(always)]
11980 fn inline_align(_context: fidl::encoding::Context) -> usize {
11981 8
11982 }
11983
11984 #[inline(always)]
11985 fn inline_size(_context: fidl::encoding::Context) -> usize {
11986 16
11987 }
11988 }
11989
11990 unsafe impl<D: fidl::encoding::ResourceDialect>
11991 fidl::encoding::Encode<WlanFullmacImplSaeHandshakeRespRequest, D>
11992 for &WlanFullmacImplSaeHandshakeRespRequest
11993 {
11994 unsafe fn encode(
11995 self,
11996 encoder: &mut fidl::encoding::Encoder<'_, D>,
11997 offset: usize,
11998 mut depth: fidl::encoding::Depth,
11999 ) -> fidl::Result<()> {
12000 encoder.debug_check_bounds::<WlanFullmacImplSaeHandshakeRespRequest>(offset);
12001 let max_ordinal: u64 = self.max_ordinal_present();
12003 encoder.write_num(max_ordinal, offset);
12004 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12005 if max_ordinal == 0 {
12007 return Ok(());
12008 }
12009 depth.increment()?;
12010 let envelope_size = 8;
12011 let bytes_len = max_ordinal as usize * envelope_size;
12012 #[allow(unused_variables)]
12013 let offset = encoder.out_of_line_offset(bytes_len);
12014 let mut _prev_end_offset: usize = 0;
12015 if 1 > max_ordinal {
12016 return Ok(());
12017 }
12018
12019 let cur_offset: usize = (1 - 1) * envelope_size;
12022
12023 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12025
12026 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
12031 self.peer_sta_address
12032 .as_ref()
12033 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
12034 encoder,
12035 offset + cur_offset,
12036 depth,
12037 )?;
12038
12039 _prev_end_offset = cur_offset + envelope_size;
12040 if 2 > max_ordinal {
12041 return Ok(());
12042 }
12043
12044 let cur_offset: usize = (2 - 1) * envelope_size;
12047
12048 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12050
12051 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
12056 self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
12057 encoder, offset + cur_offset, depth
12058 )?;
12059
12060 _prev_end_offset = cur_offset + envelope_size;
12061
12062 Ok(())
12063 }
12064 }
12065
12066 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12067 for WlanFullmacImplSaeHandshakeRespRequest
12068 {
12069 #[inline(always)]
12070 fn new_empty() -> Self {
12071 Self::default()
12072 }
12073
12074 unsafe fn decode(
12075 &mut self,
12076 decoder: &mut fidl::encoding::Decoder<'_, D>,
12077 offset: usize,
12078 mut depth: fidl::encoding::Depth,
12079 ) -> fidl::Result<()> {
12080 decoder.debug_check_bounds::<Self>(offset);
12081 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12082 None => return Err(fidl::Error::NotNullable),
12083 Some(len) => len,
12084 };
12085 if len == 0 {
12087 return Ok(());
12088 };
12089 depth.increment()?;
12090 let envelope_size = 8;
12091 let bytes_len = len * envelope_size;
12092 let offset = decoder.out_of_line_offset(bytes_len)?;
12093 let mut _next_ordinal_to_read = 0;
12095 let mut next_offset = offset;
12096 let end_offset = offset + bytes_len;
12097 _next_ordinal_to_read += 1;
12098 if next_offset >= end_offset {
12099 return Ok(());
12100 }
12101
12102 while _next_ordinal_to_read < 1 {
12104 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12105 _next_ordinal_to_read += 1;
12106 next_offset += envelope_size;
12107 }
12108
12109 let next_out_of_line = decoder.next_out_of_line();
12110 let handles_before = decoder.remaining_handles();
12111 if let Some((inlined, num_bytes, num_handles)) =
12112 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12113 {
12114 let member_inline_size =
12115 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
12116 decoder.context,
12117 );
12118 if inlined != (member_inline_size <= 4) {
12119 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12120 }
12121 let inner_offset;
12122 let mut inner_depth = depth.clone();
12123 if inlined {
12124 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12125 inner_offset = next_offset;
12126 } else {
12127 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12128 inner_depth.increment()?;
12129 }
12130 let val_ref = self
12131 .peer_sta_address
12132 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
12133 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
12134 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12135 {
12136 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12137 }
12138 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12139 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12140 }
12141 }
12142
12143 next_offset += envelope_size;
12144 _next_ordinal_to_read += 1;
12145 if next_offset >= end_offset {
12146 return Ok(());
12147 }
12148
12149 while _next_ordinal_to_read < 2 {
12151 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12152 _next_ordinal_to_read += 1;
12153 next_offset += envelope_size;
12154 }
12155
12156 let next_out_of_line = decoder.next_out_of_line();
12157 let handles_before = decoder.remaining_handles();
12158 if let Some((inlined, num_bytes, num_handles)) =
12159 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12160 {
12161 let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12162 if inlined != (member_inline_size <= 4) {
12163 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12164 }
12165 let inner_offset;
12166 let mut inner_depth = depth.clone();
12167 if inlined {
12168 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12169 inner_offset = next_offset;
12170 } else {
12171 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12172 inner_depth.increment()?;
12173 }
12174 let val_ref = self.status_code.get_or_insert_with(|| {
12175 fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
12176 });
12177 fidl::decode!(
12178 fidl_fuchsia_wlan_ieee80211__common::StatusCode,
12179 D,
12180 val_ref,
12181 decoder,
12182 inner_offset,
12183 inner_depth
12184 )?;
12185 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12186 {
12187 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12188 }
12189 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12190 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12191 }
12192 }
12193
12194 next_offset += envelope_size;
12195
12196 while next_offset < end_offset {
12198 _next_ordinal_to_read += 1;
12199 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12200 next_offset += envelope_size;
12201 }
12202
12203 Ok(())
12204 }
12205 }
12206
12207 impl WlanFullmacImplSetKeysRequest {
12208 #[inline(always)]
12209 fn max_ordinal_present(&self) -> u64 {
12210 if let Some(_) = self.key_descriptors {
12211 return 2;
12212 }
12213 if let Some(_) = self.keylist {
12214 return 1;
12215 }
12216 0
12217 }
12218 }
12219
12220 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysRequest {
12221 type Borrowed<'a> = &'a Self;
12222 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12223 value
12224 }
12225 }
12226
12227 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysRequest {
12228 type Owned = Self;
12229
12230 #[inline(always)]
12231 fn inline_align(_context: fidl::encoding::Context) -> usize {
12232 8
12233 }
12234
12235 #[inline(always)]
12236 fn inline_size(_context: fidl::encoding::Context) -> usize {
12237 16
12238 }
12239 }
12240
12241 unsafe impl<D: fidl::encoding::ResourceDialect>
12242 fidl::encoding::Encode<WlanFullmacImplSetKeysRequest, D>
12243 for &WlanFullmacImplSetKeysRequest
12244 {
12245 unsafe fn encode(
12246 self,
12247 encoder: &mut fidl::encoding::Encoder<'_, D>,
12248 offset: usize,
12249 mut depth: fidl::encoding::Depth,
12250 ) -> fidl::Result<()> {
12251 encoder.debug_check_bounds::<WlanFullmacImplSetKeysRequest>(offset);
12252 let max_ordinal: u64 = self.max_ordinal_present();
12254 encoder.write_num(max_ordinal, offset);
12255 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12256 if max_ordinal == 0 {
12258 return Ok(());
12259 }
12260 depth.increment()?;
12261 let envelope_size = 8;
12262 let bytes_len = max_ordinal as usize * envelope_size;
12263 #[allow(unused_variables)]
12264 let offset = encoder.out_of_line_offset(bytes_len);
12265 let mut _prev_end_offset: usize = 0;
12266 if 1 > max_ordinal {
12267 return Ok(());
12268 }
12269
12270 let cur_offset: usize = (1 - 1) * envelope_size;
12273
12274 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12276
12277 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D>(
12282 self.keylist.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4> as fidl::encoding::ValueTypeMarker>::borrow),
12283 encoder, offset + cur_offset, depth
12284 )?;
12285
12286 _prev_end_offset = cur_offset + envelope_size;
12287 if 2 > max_ordinal {
12288 return Ok(());
12289 }
12290
12291 let cur_offset: usize = (2 - 1) * envelope_size;
12294
12295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12297
12298 fidl::encoding::encode_in_envelope_optional::<
12303 fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>,
12304 D,
12305 >(
12306 self.key_descriptors.as_ref().map(
12307 <fidl::encoding::Vector<
12308 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12309 4,
12310 > as fidl::encoding::ValueTypeMarker>::borrow,
12311 ),
12312 encoder,
12313 offset + cur_offset,
12314 depth,
12315 )?;
12316
12317 _prev_end_offset = cur_offset + envelope_size;
12318
12319 Ok(())
12320 }
12321 }
12322
12323 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12324 for WlanFullmacImplSetKeysRequest
12325 {
12326 #[inline(always)]
12327 fn new_empty() -> Self {
12328 Self::default()
12329 }
12330
12331 unsafe fn decode(
12332 &mut self,
12333 decoder: &mut fidl::encoding::Decoder<'_, D>,
12334 offset: usize,
12335 mut depth: fidl::encoding::Depth,
12336 ) -> fidl::Result<()> {
12337 decoder.debug_check_bounds::<Self>(offset);
12338 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12339 None => return Err(fidl::Error::NotNullable),
12340 Some(len) => len,
12341 };
12342 if len == 0 {
12344 return Ok(());
12345 };
12346 depth.increment()?;
12347 let envelope_size = 8;
12348 let bytes_len = len * envelope_size;
12349 let offset = decoder.out_of_line_offset(bytes_len)?;
12350 let mut _next_ordinal_to_read = 0;
12352 let mut next_offset = offset;
12353 let end_offset = offset + bytes_len;
12354 _next_ordinal_to_read += 1;
12355 if next_offset >= end_offset {
12356 return Ok(());
12357 }
12358
12359 while _next_ordinal_to_read < 1 {
12361 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12362 _next_ordinal_to_read += 1;
12363 next_offset += envelope_size;
12364 }
12365
12366 let next_out_of_line = decoder.next_out_of_line();
12367 let handles_before = decoder.remaining_handles();
12368 if let Some((inlined, num_bytes, num_handles)) =
12369 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12370 {
12371 let member_inline_size = <fidl::encoding::Vector<
12372 fidl_fuchsia_wlan_common__common::WlanKeyConfig,
12373 4,
12374 > as fidl::encoding::TypeMarker>::inline_size(
12375 decoder.context
12376 );
12377 if inlined != (member_inline_size <= 4) {
12378 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12379 }
12380 let inner_offset;
12381 let mut inner_depth = depth.clone();
12382 if inlined {
12383 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12384 inner_offset = next_offset;
12385 } else {
12386 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12387 inner_depth.increment()?;
12388 }
12389 let val_ref =
12390 self.keylist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D));
12391 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12392 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12393 {
12394 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12395 }
12396 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12397 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12398 }
12399 }
12400
12401 next_offset += envelope_size;
12402 _next_ordinal_to_read += 1;
12403 if next_offset >= end_offset {
12404 return Ok(());
12405 }
12406
12407 while _next_ordinal_to_read < 2 {
12409 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12410 _next_ordinal_to_read += 1;
12411 next_offset += envelope_size;
12412 }
12413
12414 let next_out_of_line = decoder.next_out_of_line();
12415 let handles_before = decoder.remaining_handles();
12416 if let Some((inlined, num_bytes, num_handles)) =
12417 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12418 {
12419 let member_inline_size = <fidl::encoding::Vector<
12420 fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12421 4,
12422 > as fidl::encoding::TypeMarker>::inline_size(
12423 decoder.context
12424 );
12425 if inlined != (member_inline_size <= 4) {
12426 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12427 }
12428 let inner_offset;
12429 let mut inner_depth = depth.clone();
12430 if inlined {
12431 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12432 inner_offset = next_offset;
12433 } else {
12434 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12435 inner_depth.increment()?;
12436 }
12437 let val_ref =
12438 self.key_descriptors.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D));
12439 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12440 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12441 {
12442 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12443 }
12444 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12445 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12446 }
12447 }
12448
12449 next_offset += envelope_size;
12450
12451 while next_offset < end_offset {
12453 _next_ordinal_to_read += 1;
12454 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12455 next_offset += envelope_size;
12456 }
12457
12458 Ok(())
12459 }
12460 }
12461
12462 impl WlanFullmacImplStartBssRequest {
12463 #[inline(always)]
12464 fn max_ordinal_present(&self) -> u64 {
12465 if let Some(_) = self.vendor_ie {
12466 return 7;
12467 }
12468 if let Some(_) = self.rsne {
12469 return 6;
12470 }
12471 if let Some(_) = self.channel {
12472 return 5;
12473 }
12474 if let Some(_) = self.dtim_period {
12475 return 4;
12476 }
12477 if let Some(_) = self.beacon_period {
12478 return 3;
12479 }
12480 if let Some(_) = self.bss_type {
12481 return 2;
12482 }
12483 if let Some(_) = self.ssid {
12484 return 1;
12485 }
12486 0
12487 }
12488 }
12489
12490 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartBssRequest {
12491 type Borrowed<'a> = &'a Self;
12492 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12493 value
12494 }
12495 }
12496
12497 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartBssRequest {
12498 type Owned = Self;
12499
12500 #[inline(always)]
12501 fn inline_align(_context: fidl::encoding::Context) -> usize {
12502 8
12503 }
12504
12505 #[inline(always)]
12506 fn inline_size(_context: fidl::encoding::Context) -> usize {
12507 16
12508 }
12509 }
12510
12511 unsafe impl<D: fidl::encoding::ResourceDialect>
12512 fidl::encoding::Encode<WlanFullmacImplStartBssRequest, D>
12513 for &WlanFullmacImplStartBssRequest
12514 {
12515 unsafe fn encode(
12516 self,
12517 encoder: &mut fidl::encoding::Encoder<'_, D>,
12518 offset: usize,
12519 mut depth: fidl::encoding::Depth,
12520 ) -> fidl::Result<()> {
12521 encoder.debug_check_bounds::<WlanFullmacImplStartBssRequest>(offset);
12522 let max_ordinal: u64 = self.max_ordinal_present();
12524 encoder.write_num(max_ordinal, offset);
12525 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12526 if max_ordinal == 0 {
12528 return Ok(());
12529 }
12530 depth.increment()?;
12531 let envelope_size = 8;
12532 let bytes_len = max_ordinal as usize * envelope_size;
12533 #[allow(unused_variables)]
12534 let offset = encoder.out_of_line_offset(bytes_len);
12535 let mut _prev_end_offset: usize = 0;
12536 if 1 > max_ordinal {
12537 return Ok(());
12538 }
12539
12540 let cur_offset: usize = (1 - 1) * envelope_size;
12543
12544 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12546
12547 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
12552 self.ssid.as_ref().map(
12553 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
12554 ),
12555 encoder,
12556 offset + cur_offset,
12557 depth,
12558 )?;
12559
12560 _prev_end_offset = cur_offset + envelope_size;
12561 if 2 > max_ordinal {
12562 return Ok(());
12563 }
12564
12565 let cur_offset: usize = (2 - 1) * envelope_size;
12568
12569 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12571
12572 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssType, D>(
12577 self.bss_type.as_ref().map(<fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::ValueTypeMarker>::borrow),
12578 encoder, offset + cur_offset, depth
12579 )?;
12580
12581 _prev_end_offset = cur_offset + envelope_size;
12582 if 3 > max_ordinal {
12583 return Ok(());
12584 }
12585
12586 let cur_offset: usize = (3 - 1) * envelope_size;
12589
12590 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12592
12593 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12598 self.beacon_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12599 encoder,
12600 offset + cur_offset,
12601 depth,
12602 )?;
12603
12604 _prev_end_offset = cur_offset + envelope_size;
12605 if 4 > max_ordinal {
12606 return Ok(());
12607 }
12608
12609 let cur_offset: usize = (4 - 1) * envelope_size;
12612
12613 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12615
12616 fidl::encoding::encode_in_envelope_optional::<u32, D>(
12621 self.dtim_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12622 encoder,
12623 offset + cur_offset,
12624 depth,
12625 )?;
12626
12627 _prev_end_offset = cur_offset + envelope_size;
12628 if 5 > max_ordinal {
12629 return Ok(());
12630 }
12631
12632 let cur_offset: usize = (5 - 1) * envelope_size;
12635
12636 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12638
12639 fidl::encoding::encode_in_envelope_optional::<u8, D>(
12644 self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
12645 encoder,
12646 offset + cur_offset,
12647 depth,
12648 )?;
12649
12650 _prev_end_offset = cur_offset + envelope_size;
12651 if 6 > max_ordinal {
12652 return Ok(());
12653 }
12654
12655 let cur_offset: usize = (6 - 1) * envelope_size;
12658
12659 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12661
12662 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
12667 self.rsne.as_ref().map(
12668 <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
12669 ),
12670 encoder,
12671 offset + cur_offset,
12672 depth,
12673 )?;
12674
12675 _prev_end_offset = cur_offset + envelope_size;
12676 if 7 > max_ordinal {
12677 return Ok(());
12678 }
12679
12680 let cur_offset: usize = (7 - 1) * envelope_size;
12683
12684 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12686
12687 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
12692 self.vendor_ie.as_ref().map(
12693 <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
12694 ),
12695 encoder,
12696 offset + cur_offset,
12697 depth,
12698 )?;
12699
12700 _prev_end_offset = cur_offset + envelope_size;
12701
12702 Ok(())
12703 }
12704 }
12705
12706 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12707 for WlanFullmacImplStartBssRequest
12708 {
12709 #[inline(always)]
12710 fn new_empty() -> Self {
12711 Self::default()
12712 }
12713
12714 unsafe fn decode(
12715 &mut self,
12716 decoder: &mut fidl::encoding::Decoder<'_, D>,
12717 offset: usize,
12718 mut depth: fidl::encoding::Depth,
12719 ) -> fidl::Result<()> {
12720 decoder.debug_check_bounds::<Self>(offset);
12721 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12722 None => return Err(fidl::Error::NotNullable),
12723 Some(len) => len,
12724 };
12725 if len == 0 {
12727 return Ok(());
12728 };
12729 depth.increment()?;
12730 let envelope_size = 8;
12731 let bytes_len = len * envelope_size;
12732 let offset = decoder.out_of_line_offset(bytes_len)?;
12733 let mut _next_ordinal_to_read = 0;
12735 let mut next_offset = offset;
12736 let end_offset = offset + bytes_len;
12737 _next_ordinal_to_read += 1;
12738 if next_offset >= end_offset {
12739 return Ok(());
12740 }
12741
12742 while _next_ordinal_to_read < 1 {
12744 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12745 _next_ordinal_to_read += 1;
12746 next_offset += envelope_size;
12747 }
12748
12749 let next_out_of_line = decoder.next_out_of_line();
12750 let handles_before = decoder.remaining_handles();
12751 if let Some((inlined, num_bytes, num_handles)) =
12752 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12753 {
12754 let member_inline_size =
12755 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
12756 decoder.context,
12757 );
12758 if inlined != (member_inline_size <= 4) {
12759 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12760 }
12761 let inner_offset;
12762 let mut inner_depth = depth.clone();
12763 if inlined {
12764 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12765 inner_offset = next_offset;
12766 } else {
12767 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12768 inner_depth.increment()?;
12769 }
12770 let val_ref = self
12771 .ssid
12772 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
12773 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
12774 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12775 {
12776 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12777 }
12778 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12779 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12780 }
12781 }
12782
12783 next_offset += envelope_size;
12784 _next_ordinal_to_read += 1;
12785 if next_offset >= end_offset {
12786 return Ok(());
12787 }
12788
12789 while _next_ordinal_to_read < 2 {
12791 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12792 _next_ordinal_to_read += 1;
12793 next_offset += envelope_size;
12794 }
12795
12796 let next_out_of_line = decoder.next_out_of_line();
12797 let handles_before = decoder.remaining_handles();
12798 if let Some((inlined, num_bytes, num_handles)) =
12799 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12800 {
12801 let member_inline_size = <fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12802 if inlined != (member_inline_size <= 4) {
12803 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12804 }
12805 let inner_offset;
12806 let mut inner_depth = depth.clone();
12807 if inlined {
12808 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12809 inner_offset = next_offset;
12810 } else {
12811 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12812 inner_depth.increment()?;
12813 }
12814 let val_ref = self.bss_type.get_or_insert_with(|| {
12815 fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssType, D)
12816 });
12817 fidl::decode!(
12818 fidl_fuchsia_wlan_common__common::BssType,
12819 D,
12820 val_ref,
12821 decoder,
12822 inner_offset,
12823 inner_depth
12824 )?;
12825 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12826 {
12827 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12828 }
12829 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12830 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12831 }
12832 }
12833
12834 next_offset += envelope_size;
12835 _next_ordinal_to_read += 1;
12836 if next_offset >= end_offset {
12837 return Ok(());
12838 }
12839
12840 while _next_ordinal_to_read < 3 {
12842 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12843 _next_ordinal_to_read += 1;
12844 next_offset += envelope_size;
12845 }
12846
12847 let next_out_of_line = decoder.next_out_of_line();
12848 let handles_before = decoder.remaining_handles();
12849 if let Some((inlined, num_bytes, num_handles)) =
12850 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12851 {
12852 let member_inline_size =
12853 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12854 if inlined != (member_inline_size <= 4) {
12855 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12856 }
12857 let inner_offset;
12858 let mut inner_depth = depth.clone();
12859 if inlined {
12860 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12861 inner_offset = next_offset;
12862 } else {
12863 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12864 inner_depth.increment()?;
12865 }
12866 let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12867 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12868 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12869 {
12870 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12871 }
12872 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12873 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12874 }
12875 }
12876
12877 next_offset += envelope_size;
12878 _next_ordinal_to_read += 1;
12879 if next_offset >= end_offset {
12880 return Ok(());
12881 }
12882
12883 while _next_ordinal_to_read < 4 {
12885 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12886 _next_ordinal_to_read += 1;
12887 next_offset += envelope_size;
12888 }
12889
12890 let next_out_of_line = decoder.next_out_of_line();
12891 let handles_before = decoder.remaining_handles();
12892 if let Some((inlined, num_bytes, num_handles)) =
12893 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12894 {
12895 let member_inline_size =
12896 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12897 if inlined != (member_inline_size <= 4) {
12898 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12899 }
12900 let inner_offset;
12901 let mut inner_depth = depth.clone();
12902 if inlined {
12903 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12904 inner_offset = next_offset;
12905 } else {
12906 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12907 inner_depth.increment()?;
12908 }
12909 let val_ref = self.dtim_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12910 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12911 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12912 {
12913 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12914 }
12915 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12916 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12917 }
12918 }
12919
12920 next_offset += envelope_size;
12921 _next_ordinal_to_read += 1;
12922 if next_offset >= end_offset {
12923 return Ok(());
12924 }
12925
12926 while _next_ordinal_to_read < 5 {
12928 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12929 _next_ordinal_to_read += 1;
12930 next_offset += envelope_size;
12931 }
12932
12933 let next_out_of_line = decoder.next_out_of_line();
12934 let handles_before = decoder.remaining_handles();
12935 if let Some((inlined, num_bytes, num_handles)) =
12936 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12937 {
12938 let member_inline_size =
12939 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12940 if inlined != (member_inline_size <= 4) {
12941 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12942 }
12943 let inner_offset;
12944 let mut inner_depth = depth.clone();
12945 if inlined {
12946 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12947 inner_offset = next_offset;
12948 } else {
12949 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12950 inner_depth.increment()?;
12951 }
12952 let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
12953 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
12954 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12955 {
12956 return Err(fidl::Error::InvalidNumBytesInEnvelope);
12957 }
12958 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12959 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12960 }
12961 }
12962
12963 next_offset += envelope_size;
12964 _next_ordinal_to_read += 1;
12965 if next_offset >= end_offset {
12966 return Ok(());
12967 }
12968
12969 while _next_ordinal_to_read < 6 {
12971 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12972 _next_ordinal_to_read += 1;
12973 next_offset += envelope_size;
12974 }
12975
12976 let next_out_of_line = decoder.next_out_of_line();
12977 let handles_before = decoder.remaining_handles();
12978 if let Some((inlined, num_bytes, num_handles)) =
12979 fidl::encoding::decode_envelope_header(decoder, next_offset)?
12980 {
12981 let member_inline_size =
12982 <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
12983 decoder.context,
12984 );
12985 if inlined != (member_inline_size <= 4) {
12986 return Err(fidl::Error::InvalidInlineBitInEnvelope);
12987 }
12988 let inner_offset;
12989 let mut inner_depth = depth.clone();
12990 if inlined {
12991 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12992 inner_offset = next_offset;
12993 } else {
12994 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12995 inner_depth.increment()?;
12996 }
12997 let val_ref = self
12998 .rsne
12999 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
13000 fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
13001 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13002 {
13003 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13004 }
13005 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13006 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13007 }
13008 }
13009
13010 next_offset += envelope_size;
13011 _next_ordinal_to_read += 1;
13012 if next_offset >= end_offset {
13013 return Ok(());
13014 }
13015
13016 while _next_ordinal_to_read < 7 {
13018 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13019 _next_ordinal_to_read += 1;
13020 next_offset += envelope_size;
13021 }
13022
13023 let next_out_of_line = decoder.next_out_of_line();
13024 let handles_before = decoder.remaining_handles();
13025 if let Some((inlined, num_bytes, num_handles)) =
13026 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13027 {
13028 let member_inline_size =
13029 <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
13030 decoder.context,
13031 );
13032 if inlined != (member_inline_size <= 4) {
13033 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13034 }
13035 let inner_offset;
13036 let mut inner_depth = depth.clone();
13037 if inlined {
13038 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13039 inner_offset = next_offset;
13040 } else {
13041 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13042 inner_depth.increment()?;
13043 }
13044 let val_ref = self
13045 .vendor_ie
13046 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
13047 fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
13048 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13049 {
13050 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13051 }
13052 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13053 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13054 }
13055 }
13056
13057 next_offset += envelope_size;
13058
13059 while next_offset < end_offset {
13061 _next_ordinal_to_read += 1;
13062 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13063 next_offset += envelope_size;
13064 }
13065
13066 Ok(())
13067 }
13068 }
13069
13070 impl WlanFullmacImplStartScanRequest {
13071 #[inline(always)]
13072 fn max_ordinal_present(&self) -> u64 {
13073 if let Some(_) = self.max_channel_time {
13074 return 6;
13075 }
13076 if let Some(_) = self.min_channel_time {
13077 return 5;
13078 }
13079 if let Some(_) = self.ssids {
13080 return 4;
13081 }
13082 if let Some(_) = self.channels {
13083 return 3;
13084 }
13085 if let Some(_) = self.scan_type {
13086 return 2;
13087 }
13088 if let Some(_) = self.txn_id {
13089 return 1;
13090 }
13091 0
13092 }
13093 }
13094
13095 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartScanRequest {
13096 type Borrowed<'a> = &'a Self;
13097 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13098 value
13099 }
13100 }
13101
13102 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartScanRequest {
13103 type Owned = Self;
13104
13105 #[inline(always)]
13106 fn inline_align(_context: fidl::encoding::Context) -> usize {
13107 8
13108 }
13109
13110 #[inline(always)]
13111 fn inline_size(_context: fidl::encoding::Context) -> usize {
13112 16
13113 }
13114 }
13115
13116 unsafe impl<D: fidl::encoding::ResourceDialect>
13117 fidl::encoding::Encode<WlanFullmacImplStartScanRequest, D>
13118 for &WlanFullmacImplStartScanRequest
13119 {
13120 unsafe fn encode(
13121 self,
13122 encoder: &mut fidl::encoding::Encoder<'_, D>,
13123 offset: usize,
13124 mut depth: fidl::encoding::Depth,
13125 ) -> fidl::Result<()> {
13126 encoder.debug_check_bounds::<WlanFullmacImplStartScanRequest>(offset);
13127 let max_ordinal: u64 = self.max_ordinal_present();
13129 encoder.write_num(max_ordinal, offset);
13130 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13131 if max_ordinal == 0 {
13133 return Ok(());
13134 }
13135 depth.increment()?;
13136 let envelope_size = 8;
13137 let bytes_len = max_ordinal as usize * envelope_size;
13138 #[allow(unused_variables)]
13139 let offset = encoder.out_of_line_offset(bytes_len);
13140 let mut _prev_end_offset: usize = 0;
13141 if 1 > max_ordinal {
13142 return Ok(());
13143 }
13144
13145 let cur_offset: usize = (1 - 1) * envelope_size;
13148
13149 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13151
13152 fidl::encoding::encode_in_envelope_optional::<u64, D>(
13157 self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
13158 encoder,
13159 offset + cur_offset,
13160 depth,
13161 )?;
13162
13163 _prev_end_offset = cur_offset + envelope_size;
13164 if 2 > max_ordinal {
13165 return Ok(());
13166 }
13167
13168 let cur_offset: usize = (2 - 1) * envelope_size;
13171
13172 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13174
13175 fidl::encoding::encode_in_envelope_optional::<WlanScanType, D>(
13180 self.scan_type
13181 .as_ref()
13182 .map(<WlanScanType as fidl::encoding::ValueTypeMarker>::borrow),
13183 encoder,
13184 offset + cur_offset,
13185 depth,
13186 )?;
13187
13188 _prev_end_offset = cur_offset + envelope_size;
13189 if 3 > max_ordinal {
13190 return Ok(());
13191 }
13192
13193 let cur_offset: usize = (3 - 1) * envelope_size;
13196
13197 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13199
13200 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
13205 self.channels.as_ref().map(
13206 <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
13207 ),
13208 encoder,
13209 offset + cur_offset,
13210 depth,
13211 )?;
13212
13213 _prev_end_offset = cur_offset + envelope_size;
13214 if 4 > max_ordinal {
13215 return Ok(());
13216 }
13217
13218 let cur_offset: usize = (4 - 1) * envelope_size;
13221
13222 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13224
13225 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>(
13230 self.ssids.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow),
13231 encoder, offset + cur_offset, depth
13232 )?;
13233
13234 _prev_end_offset = cur_offset + envelope_size;
13235 if 5 > max_ordinal {
13236 return Ok(());
13237 }
13238
13239 let cur_offset: usize = (5 - 1) * envelope_size;
13242
13243 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13245
13246 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13251 self.min_channel_time
13252 .as_ref()
13253 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13254 encoder,
13255 offset + cur_offset,
13256 depth,
13257 )?;
13258
13259 _prev_end_offset = cur_offset + envelope_size;
13260 if 6 > max_ordinal {
13261 return Ok(());
13262 }
13263
13264 let cur_offset: usize = (6 - 1) * envelope_size;
13267
13268 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13270
13271 fidl::encoding::encode_in_envelope_optional::<u32, D>(
13276 self.max_channel_time
13277 .as_ref()
13278 .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13279 encoder,
13280 offset + cur_offset,
13281 depth,
13282 )?;
13283
13284 _prev_end_offset = cur_offset + envelope_size;
13285
13286 Ok(())
13287 }
13288 }
13289
13290 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13291 for WlanFullmacImplStartScanRequest
13292 {
13293 #[inline(always)]
13294 fn new_empty() -> Self {
13295 Self::default()
13296 }
13297
13298 unsafe fn decode(
13299 &mut self,
13300 decoder: &mut fidl::encoding::Decoder<'_, D>,
13301 offset: usize,
13302 mut depth: fidl::encoding::Depth,
13303 ) -> fidl::Result<()> {
13304 decoder.debug_check_bounds::<Self>(offset);
13305 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13306 None => return Err(fidl::Error::NotNullable),
13307 Some(len) => len,
13308 };
13309 if len == 0 {
13311 return Ok(());
13312 };
13313 depth.increment()?;
13314 let envelope_size = 8;
13315 let bytes_len = len * envelope_size;
13316 let offset = decoder.out_of_line_offset(bytes_len)?;
13317 let mut _next_ordinal_to_read = 0;
13319 let mut next_offset = offset;
13320 let end_offset = offset + bytes_len;
13321 _next_ordinal_to_read += 1;
13322 if next_offset >= end_offset {
13323 return Ok(());
13324 }
13325
13326 while _next_ordinal_to_read < 1 {
13328 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13329 _next_ordinal_to_read += 1;
13330 next_offset += envelope_size;
13331 }
13332
13333 let next_out_of_line = decoder.next_out_of_line();
13334 let handles_before = decoder.remaining_handles();
13335 if let Some((inlined, num_bytes, num_handles)) =
13336 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13337 {
13338 let member_inline_size =
13339 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13340 if inlined != (member_inline_size <= 4) {
13341 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13342 }
13343 let inner_offset;
13344 let mut inner_depth = depth.clone();
13345 if inlined {
13346 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13347 inner_offset = next_offset;
13348 } else {
13349 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13350 inner_depth.increment()?;
13351 }
13352 let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
13353 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
13354 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13355 {
13356 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13357 }
13358 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13359 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13360 }
13361 }
13362
13363 next_offset += envelope_size;
13364 _next_ordinal_to_read += 1;
13365 if next_offset >= end_offset {
13366 return Ok(());
13367 }
13368
13369 while _next_ordinal_to_read < 2 {
13371 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13372 _next_ordinal_to_read += 1;
13373 next_offset += envelope_size;
13374 }
13375
13376 let next_out_of_line = decoder.next_out_of_line();
13377 let handles_before = decoder.remaining_handles();
13378 if let Some((inlined, num_bytes, num_handles)) =
13379 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13380 {
13381 let member_inline_size =
13382 <WlanScanType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13383 if inlined != (member_inline_size <= 4) {
13384 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13385 }
13386 let inner_offset;
13387 let mut inner_depth = depth.clone();
13388 if inlined {
13389 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13390 inner_offset = next_offset;
13391 } else {
13392 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13393 inner_depth.increment()?;
13394 }
13395 let val_ref =
13396 self.scan_type.get_or_insert_with(|| fidl::new_empty!(WlanScanType, D));
13397 fidl::decode!(WlanScanType, D, val_ref, decoder, inner_offset, inner_depth)?;
13398 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13399 {
13400 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13401 }
13402 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13403 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13404 }
13405 }
13406
13407 next_offset += envelope_size;
13408 _next_ordinal_to_read += 1;
13409 if next_offset >= end_offset {
13410 return Ok(());
13411 }
13412
13413 while _next_ordinal_to_read < 3 {
13415 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13416 _next_ordinal_to_read += 1;
13417 next_offset += envelope_size;
13418 }
13419
13420 let next_out_of_line = decoder.next_out_of_line();
13421 let handles_before = decoder.remaining_handles();
13422 if let Some((inlined, num_bytes, num_handles)) =
13423 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13424 {
13425 let member_inline_size =
13426 <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
13427 decoder.context,
13428 );
13429 if inlined != (member_inline_size <= 4) {
13430 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13431 }
13432 let inner_offset;
13433 let mut inner_depth = depth.clone();
13434 if inlined {
13435 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13436 inner_offset = next_offset;
13437 } else {
13438 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13439 inner_depth.increment()?;
13440 }
13441 let val_ref = self
13442 .channels
13443 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
13444 fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
13445 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13446 {
13447 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13448 }
13449 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13450 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13451 }
13452 }
13453
13454 next_offset += envelope_size;
13455 _next_ordinal_to_read += 1;
13456 if next_offset >= end_offset {
13457 return Ok(());
13458 }
13459
13460 while _next_ordinal_to_read < 4 {
13462 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13463 _next_ordinal_to_read += 1;
13464 next_offset += envelope_size;
13465 }
13466
13467 let next_out_of_line = decoder.next_out_of_line();
13468 let handles_before = decoder.remaining_handles();
13469 if let Some((inlined, num_bytes, num_handles)) =
13470 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13471 {
13472 let member_inline_size = <fidl::encoding::UnboundedVector<
13473 fidl::encoding::Vector<u8, 32>,
13474 > as fidl::encoding::TypeMarker>::inline_size(
13475 decoder.context
13476 );
13477 if inlined != (member_inline_size <= 4) {
13478 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13479 }
13480 let inner_offset;
13481 let mut inner_depth = depth.clone();
13482 if inlined {
13483 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13484 inner_offset = next_offset;
13485 } else {
13486 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13487 inner_depth.increment()?;
13488 }
13489 let val_ref = self.ssids.get_or_insert_with(|| {
13490 fidl::new_empty!(
13491 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13492 D
13493 )
13494 });
13495 fidl::decode!(
13496 fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13497 D,
13498 val_ref,
13499 decoder,
13500 inner_offset,
13501 inner_depth
13502 )?;
13503 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13504 {
13505 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13506 }
13507 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13508 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13509 }
13510 }
13511
13512 next_offset += envelope_size;
13513 _next_ordinal_to_read += 1;
13514 if next_offset >= end_offset {
13515 return Ok(());
13516 }
13517
13518 while _next_ordinal_to_read < 5 {
13520 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13521 _next_ordinal_to_read += 1;
13522 next_offset += envelope_size;
13523 }
13524
13525 let next_out_of_line = decoder.next_out_of_line();
13526 let handles_before = decoder.remaining_handles();
13527 if let Some((inlined, num_bytes, num_handles)) =
13528 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13529 {
13530 let member_inline_size =
13531 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13532 if inlined != (member_inline_size <= 4) {
13533 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13534 }
13535 let inner_offset;
13536 let mut inner_depth = depth.clone();
13537 if inlined {
13538 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13539 inner_offset = next_offset;
13540 } else {
13541 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13542 inner_depth.increment()?;
13543 }
13544 let val_ref = self.min_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13545 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13546 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13547 {
13548 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13549 }
13550 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13551 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13552 }
13553 }
13554
13555 next_offset += envelope_size;
13556 _next_ordinal_to_read += 1;
13557 if next_offset >= end_offset {
13558 return Ok(());
13559 }
13560
13561 while _next_ordinal_to_read < 6 {
13563 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13564 _next_ordinal_to_read += 1;
13565 next_offset += envelope_size;
13566 }
13567
13568 let next_out_of_line = decoder.next_out_of_line();
13569 let handles_before = decoder.remaining_handles();
13570 if let Some((inlined, num_bytes, num_handles)) =
13571 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13572 {
13573 let member_inline_size =
13574 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13575 if inlined != (member_inline_size <= 4) {
13576 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13577 }
13578 let inner_offset;
13579 let mut inner_depth = depth.clone();
13580 if inlined {
13581 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13582 inner_offset = next_offset;
13583 } else {
13584 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13585 inner_depth.increment()?;
13586 }
13587 let val_ref = self.max_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13588 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13589 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13590 {
13591 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13592 }
13593 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13594 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13595 }
13596 }
13597
13598 next_offset += envelope_size;
13599
13600 while next_offset < end_offset {
13602 _next_ordinal_to_read += 1;
13603 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13604 next_offset += envelope_size;
13605 }
13606
13607 Ok(())
13608 }
13609 }
13610
13611 impl WlanFullmacImplStopBssRequest {
13612 #[inline(always)]
13613 fn max_ordinal_present(&self) -> u64 {
13614 if let Some(_) = self.ssid {
13615 return 1;
13616 }
13617 0
13618 }
13619 }
13620
13621 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStopBssRequest {
13622 type Borrowed<'a> = &'a Self;
13623 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13624 value
13625 }
13626 }
13627
13628 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStopBssRequest {
13629 type Owned = Self;
13630
13631 #[inline(always)]
13632 fn inline_align(_context: fidl::encoding::Context) -> usize {
13633 8
13634 }
13635
13636 #[inline(always)]
13637 fn inline_size(_context: fidl::encoding::Context) -> usize {
13638 16
13639 }
13640 }
13641
13642 unsafe impl<D: fidl::encoding::ResourceDialect>
13643 fidl::encoding::Encode<WlanFullmacImplStopBssRequest, D>
13644 for &WlanFullmacImplStopBssRequest
13645 {
13646 unsafe fn encode(
13647 self,
13648 encoder: &mut fidl::encoding::Encoder<'_, D>,
13649 offset: usize,
13650 mut depth: fidl::encoding::Depth,
13651 ) -> fidl::Result<()> {
13652 encoder.debug_check_bounds::<WlanFullmacImplStopBssRequest>(offset);
13653 let max_ordinal: u64 = self.max_ordinal_present();
13655 encoder.write_num(max_ordinal, offset);
13656 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13657 if max_ordinal == 0 {
13659 return Ok(());
13660 }
13661 depth.increment()?;
13662 let envelope_size = 8;
13663 let bytes_len = max_ordinal as usize * envelope_size;
13664 #[allow(unused_variables)]
13665 let offset = encoder.out_of_line_offset(bytes_len);
13666 let mut _prev_end_offset: usize = 0;
13667 if 1 > max_ordinal {
13668 return Ok(());
13669 }
13670
13671 let cur_offset: usize = (1 - 1) * envelope_size;
13674
13675 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13677
13678 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
13683 self.ssid.as_ref().map(
13684 <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
13685 ),
13686 encoder,
13687 offset + cur_offset,
13688 depth,
13689 )?;
13690
13691 _prev_end_offset = cur_offset + envelope_size;
13692
13693 Ok(())
13694 }
13695 }
13696
13697 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13698 for WlanFullmacImplStopBssRequest
13699 {
13700 #[inline(always)]
13701 fn new_empty() -> Self {
13702 Self::default()
13703 }
13704
13705 unsafe fn decode(
13706 &mut self,
13707 decoder: &mut fidl::encoding::Decoder<'_, D>,
13708 offset: usize,
13709 mut depth: fidl::encoding::Depth,
13710 ) -> fidl::Result<()> {
13711 decoder.debug_check_bounds::<Self>(offset);
13712 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13713 None => return Err(fidl::Error::NotNullable),
13714 Some(len) => len,
13715 };
13716 if len == 0 {
13718 return Ok(());
13719 };
13720 depth.increment()?;
13721 let envelope_size = 8;
13722 let bytes_len = len * envelope_size;
13723 let offset = decoder.out_of_line_offset(bytes_len)?;
13724 let mut _next_ordinal_to_read = 0;
13726 let mut next_offset = offset;
13727 let end_offset = offset + bytes_len;
13728 _next_ordinal_to_read += 1;
13729 if next_offset >= end_offset {
13730 return Ok(());
13731 }
13732
13733 while _next_ordinal_to_read < 1 {
13735 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13736 _next_ordinal_to_read += 1;
13737 next_offset += envelope_size;
13738 }
13739
13740 let next_out_of_line = decoder.next_out_of_line();
13741 let handles_before = decoder.remaining_handles();
13742 if let Some((inlined, num_bytes, num_handles)) =
13743 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13744 {
13745 let member_inline_size =
13746 <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
13747 decoder.context,
13748 );
13749 if inlined != (member_inline_size <= 4) {
13750 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13751 }
13752 let inner_offset;
13753 let mut inner_depth = depth.clone();
13754 if inlined {
13755 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13756 inner_offset = next_offset;
13757 } else {
13758 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13759 inner_depth.increment()?;
13760 }
13761 let val_ref = self
13762 .ssid
13763 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
13764 fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
13765 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13766 {
13767 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13768 }
13769 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13770 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13771 }
13772 }
13773
13774 next_offset += envelope_size;
13775
13776 while next_offset < end_offset {
13778 _next_ordinal_to_read += 1;
13779 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13780 next_offset += envelope_size;
13781 }
13782
13783 Ok(())
13784 }
13785 }
13786
13787 impl WlanFullmacImplQueryResponse {
13788 #[inline(always)]
13789 fn max_ordinal_present(&self) -> u64 {
13790 if let Some(_) = self.band_caps {
13791 return 3;
13792 }
13793 if let Some(_) = self.role {
13794 return 2;
13795 }
13796 if let Some(_) = self.sta_addr {
13797 return 1;
13798 }
13799 0
13800 }
13801 }
13802
13803 impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryResponse {
13804 type Borrowed<'a> = &'a Self;
13805 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13806 value
13807 }
13808 }
13809
13810 unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryResponse {
13811 type Owned = Self;
13812
13813 #[inline(always)]
13814 fn inline_align(_context: fidl::encoding::Context) -> usize {
13815 8
13816 }
13817
13818 #[inline(always)]
13819 fn inline_size(_context: fidl::encoding::Context) -> usize {
13820 16
13821 }
13822 }
13823
13824 unsafe impl<D: fidl::encoding::ResourceDialect>
13825 fidl::encoding::Encode<WlanFullmacImplQueryResponse, D> for &WlanFullmacImplQueryResponse
13826 {
13827 unsafe fn encode(
13828 self,
13829 encoder: &mut fidl::encoding::Encoder<'_, D>,
13830 offset: usize,
13831 mut depth: fidl::encoding::Depth,
13832 ) -> fidl::Result<()> {
13833 encoder.debug_check_bounds::<WlanFullmacImplQueryResponse>(offset);
13834 let max_ordinal: u64 = self.max_ordinal_present();
13836 encoder.write_num(max_ordinal, offset);
13837 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13838 if max_ordinal == 0 {
13840 return Ok(());
13841 }
13842 depth.increment()?;
13843 let envelope_size = 8;
13844 let bytes_len = max_ordinal as usize * envelope_size;
13845 #[allow(unused_variables)]
13846 let offset = encoder.out_of_line_offset(bytes_len);
13847 let mut _prev_end_offset: usize = 0;
13848 if 1 > max_ordinal {
13849 return Ok(());
13850 }
13851
13852 let cur_offset: usize = (1 - 1) * envelope_size;
13855
13856 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13858
13859 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
13864 self.sta_addr
13865 .as_ref()
13866 .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
13867 encoder,
13868 offset + cur_offset,
13869 depth,
13870 )?;
13871
13872 _prev_end_offset = cur_offset + envelope_size;
13873 if 2 > max_ordinal {
13874 return Ok(());
13875 }
13876
13877 let cur_offset: usize = (2 - 1) * envelope_size;
13880
13881 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13883
13884 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
13889 self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
13890 encoder, offset + cur_offset, depth
13891 )?;
13892
13893 _prev_end_offset = cur_offset + envelope_size;
13894 if 3 > max_ordinal {
13895 return Ok(());
13896 }
13897
13898 let cur_offset: usize = (3 - 1) * envelope_size;
13901
13902 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13904
13905 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<BandCapability, 16>, D>(
13910 self.band_caps.as_ref().map(<fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow),
13911 encoder, offset + cur_offset, depth
13912 )?;
13913
13914 _prev_end_offset = cur_offset + envelope_size;
13915
13916 Ok(())
13917 }
13918 }
13919
13920 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13921 for WlanFullmacImplQueryResponse
13922 {
13923 #[inline(always)]
13924 fn new_empty() -> Self {
13925 Self::default()
13926 }
13927
13928 unsafe fn decode(
13929 &mut self,
13930 decoder: &mut fidl::encoding::Decoder<'_, D>,
13931 offset: usize,
13932 mut depth: fidl::encoding::Depth,
13933 ) -> fidl::Result<()> {
13934 decoder.debug_check_bounds::<Self>(offset);
13935 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13936 None => return Err(fidl::Error::NotNullable),
13937 Some(len) => len,
13938 };
13939 if len == 0 {
13941 return Ok(());
13942 };
13943 depth.increment()?;
13944 let envelope_size = 8;
13945 let bytes_len = len * envelope_size;
13946 let offset = decoder.out_of_line_offset(bytes_len)?;
13947 let mut _next_ordinal_to_read = 0;
13949 let mut next_offset = offset;
13950 let end_offset = offset + bytes_len;
13951 _next_ordinal_to_read += 1;
13952 if next_offset >= end_offset {
13953 return Ok(());
13954 }
13955
13956 while _next_ordinal_to_read < 1 {
13958 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13959 _next_ordinal_to_read += 1;
13960 next_offset += envelope_size;
13961 }
13962
13963 let next_out_of_line = decoder.next_out_of_line();
13964 let handles_before = decoder.remaining_handles();
13965 if let Some((inlined, num_bytes, num_handles)) =
13966 fidl::encoding::decode_envelope_header(decoder, next_offset)?
13967 {
13968 let member_inline_size =
13969 <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
13970 decoder.context,
13971 );
13972 if inlined != (member_inline_size <= 4) {
13973 return Err(fidl::Error::InvalidInlineBitInEnvelope);
13974 }
13975 let inner_offset;
13976 let mut inner_depth = depth.clone();
13977 if inlined {
13978 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13979 inner_offset = next_offset;
13980 } else {
13981 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13982 inner_depth.increment()?;
13983 }
13984 let val_ref = self
13985 .sta_addr
13986 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
13987 fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
13988 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13989 {
13990 return Err(fidl::Error::InvalidNumBytesInEnvelope);
13991 }
13992 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13993 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13994 }
13995 }
13996
13997 next_offset += envelope_size;
13998 _next_ordinal_to_read += 1;
13999 if next_offset >= end_offset {
14000 return Ok(());
14001 }
14002
14003 while _next_ordinal_to_read < 2 {
14005 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14006 _next_ordinal_to_read += 1;
14007 next_offset += envelope_size;
14008 }
14009
14010 let next_out_of_line = decoder.next_out_of_line();
14011 let handles_before = decoder.remaining_handles();
14012 if let Some((inlined, num_bytes, num_handles)) =
14013 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14014 {
14015 let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14016 if inlined != (member_inline_size <= 4) {
14017 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14018 }
14019 let inner_offset;
14020 let mut inner_depth = depth.clone();
14021 if inlined {
14022 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14023 inner_offset = next_offset;
14024 } else {
14025 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14026 inner_depth.increment()?;
14027 }
14028 let val_ref = self.role.get_or_insert_with(|| {
14029 fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
14030 });
14031 fidl::decode!(
14032 fidl_fuchsia_wlan_common__common::WlanMacRole,
14033 D,
14034 val_ref,
14035 decoder,
14036 inner_offset,
14037 inner_depth
14038 )?;
14039 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14040 {
14041 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14042 }
14043 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14044 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14045 }
14046 }
14047
14048 next_offset += envelope_size;
14049 _next_ordinal_to_read += 1;
14050 if next_offset >= end_offset {
14051 return Ok(());
14052 }
14053
14054 while _next_ordinal_to_read < 3 {
14056 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14057 _next_ordinal_to_read += 1;
14058 next_offset += envelope_size;
14059 }
14060
14061 let next_out_of_line = decoder.next_out_of_line();
14062 let handles_before = decoder.remaining_handles();
14063 if let Some((inlined, num_bytes, num_handles)) =
14064 fidl::encoding::decode_envelope_header(decoder, next_offset)?
14065 {
14066 let member_inline_size = <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14067 if inlined != (member_inline_size <= 4) {
14068 return Err(fidl::Error::InvalidInlineBitInEnvelope);
14069 }
14070 let inner_offset;
14071 let mut inner_depth = depth.clone();
14072 if inlined {
14073 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14074 inner_offset = next_offset;
14075 } else {
14076 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14077 inner_depth.increment()?;
14078 }
14079 let val_ref = self.band_caps.get_or_insert_with(
14080 || fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
14081 );
14082 fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
14083 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14084 {
14085 return Err(fidl::Error::InvalidNumBytesInEnvelope);
14086 }
14087 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14088 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14089 }
14090 }
14091
14092 next_offset += envelope_size;
14093
14094 while next_offset < end_offset {
14096 _next_ordinal_to_read += 1;
14097 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14098 next_offset += envelope_size;
14099 }
14100
14101 Ok(())
14102 }
14103 }
14104}